bundler-plus 4.0.15

data/lib/bundler/vendor/thor/lib/thor/runner.rb

@@ -0,0 +1,335 @@
+require_relative "../thor"
+require_relative "group"
+
+require "digest/sha2"
+require "pathname" unless defined?(Pathname)
+
+class Bundler::Thor::Runner < Bundler::Thor #:nodoc:
+  map "-T" => :list, "-i" => :install, "-u" => :update, "-v" => :version
+
+  def self.banner(command, all = false, subcommand = false)
+    "thor " + command.formatted_usage(self, all, subcommand)
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+
+  # Override Bundler::Thor#help so it can give information about any class and any method.
+  #
+  def help(meth = nil)
+    if meth && !respond_to?(meth)
+      initialize_thorfiles(meth)
+      klass, command = Bundler::Thor::Util.find_class_and_command_by_namespace(meth)
+      self.class.handle_no_command_error(command, false) if klass.nil?
+      klass.start(["-h", command].compact, shell: shell)
+    else
+      super
+    end
+  end
+
+  # If a command is not found on Bundler::Thor::Runner, method missing is invoked and
+  # Bundler::Thor::Runner is then responsible for finding the command in all classes.
+  #
+  def method_missing(meth, *args)
+    meth = meth.to_s
+    initialize_thorfiles(meth)
+    klass, command = Bundler::Thor::Util.find_class_and_command_by_namespace(meth)
+    self.class.handle_no_command_error(command, false) if klass.nil?
+    args.unshift(command) if command
+    klass.start(args, shell: shell)
+  end
+
+  desc "install NAME", "Install an optionally named Bundler::Thor file into your system commands"
+  method_options as: :string, relative: :boolean, force: :boolean
+  def install(name) # rubocop:disable Metrics/MethodLength
+    initialize_thorfiles
+
+    is_uri  = name =~ %r{^https?\://}
+
+    if is_uri
+      base = name
+      package = :file
+      require "open-uri"
+      begin
+        contents = URI.open(name, &:read)
+      rescue OpenURI::HTTPError
+        raise Error, "Error opening URI '#{name}'"
+      end
+    else
+      # If a directory name is provided as the argument, look for a 'main.thor'
+      # command in said directory.
+      begin
+        if File.directory?(File.expand_path(name))
+          base = File.join(name, "main.thor")
+          package = :directory
+          contents = File.open(base, &:read)
+        else
+          base = name
+          package = :file
+          require "open-uri"
+          contents = URI.open(name, &:read)
+        end
+      rescue Errno::ENOENT
+        raise Error, "Error opening file '#{name}'"
+      end
+    end
+
+    say "Your Thorfile contains:"
+    say contents
+
+    unless options["force"]
+      return false if no?("Do you wish to continue [y/N]?")
+    end
+
+    as = options["as"] || begin
+      first_line = contents.split("\n")[0]
+      (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
+    end
+
+    unless as
+      basename = File.basename(name)
+      as = ask("Please specify a name for #{name} in the system repository [#{basename}]:")
+      as = basename if as.empty?
+    end
+
+    location = if options[:relative] || is_uri
+      name
+    else
+      File.expand_path(name)
+    end
+
+    thor_yaml[as] = {
+      filename: Digest::SHA256.hexdigest(name + as),
+      location: location,
+      namespaces: Bundler::Thor::Util.namespaces_in_content(contents, base)
+    }
+
+    save_yaml(thor_yaml)
+    say "Storing thor file in your system repository"
+    destination = File.join(thor_root, thor_yaml[as][:filename])
+
+    if package == :file
+      File.open(destination, "w") { |f| f.puts contents }
+    else
+      require "fileutils"
+      FileUtils.cp_r(name, destination)
+    end
+
+    thor_yaml[as][:filename] # Indicate success
+  end
+
+  desc "version", "Show Bundler::Thor version"
+  def version
+    require_relative "version"
+    say "Bundler::Thor #{Bundler::Thor::VERSION}"
+  end
+
+  desc "uninstall NAME", "Uninstall a named Bundler::Thor module"
+  def uninstall(name)
+    raise Error, "Can't find module '#{name}'" unless thor_yaml[name]
+    say "Uninstalling #{name}."
+    require "fileutils"
+    FileUtils.rm_rf(File.join(thor_root, (thor_yaml[name][:filename]).to_s))
+
+    thor_yaml.delete(name)
+    save_yaml(thor_yaml)
+
+    puts "Done."
+  end
+
+  desc "update NAME", "Update a Bundler::Thor file from its original location"
+  def update(name)
+    raise Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]
+
+    say "Updating '#{name}' from #{thor_yaml[name][:location]}"
+
+    old_filename = thor_yaml[name][:filename]
+    self.options = options.merge("as" => name)
+
+    if File.directory? File.expand_path(name)
+      require "fileutils"
+      FileUtils.rm_rf(File.join(thor_root, old_filename))
+
+      thor_yaml.delete(old_filename)
+      save_yaml(thor_yaml)
+
+      filename = install(name)
+    else
+      filename = install(thor_yaml[name][:location])
+    end
+
+    File.delete(File.join(thor_root, old_filename)) unless filename == old_filename
+  end
+
+  desc "installed", "List the installed Bundler::Thor modules and commands"
+  method_options internal: :boolean
+  def installed
+    initialize_thorfiles(nil, true)
+    display_klasses(true, options["internal"])
+  end
+
+  desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
+  method_options substring: :boolean, group: :string, all: :boolean, debug: :boolean
+  def list(search = "")
+    initialize_thorfiles
+
+    search = ".*#{search}" if options["substring"]
+    search = /^#{search}.*/i
+    group  = options[:group] || "standard"
+
+    klasses = Bundler::Thor::Base.subclasses.select do |k|
+      (options[:all] || k.group == group) && k.namespace =~ search
+    end
+
+    display_klasses(false, false, klasses)
+  end
+
+private
+
+  def thor_root
+    Bundler::Thor::Util.thor_root
+  end
+
+  def thor_yaml
+    @thor_yaml ||= begin
+      yaml_file = File.join(thor_root, "thor.yml")
+      require "yaml"
+      yaml = YAML.load_file(yaml_file) if File.exist?(yaml_file)
+      yaml || {}
+    end
+  end
+
+  # Save the yaml file. If none exists in thor root, creates one.
+  #
+  def save_yaml(yaml)
+    yaml_file = File.join(thor_root, "thor.yml")
+
+    unless File.exist?(yaml_file)
+      require "fileutils"
+      FileUtils.mkdir_p(thor_root)
+      yaml_file = File.join(thor_root, "thor.yml")
+      FileUtils.touch(yaml_file)
+    end
+
+    File.open(yaml_file, "w") { |f| f.puts yaml.to_yaml }
+  end
+
+  # Load the Thorfiles. If relevant_to is supplied, looks for specific files
+  # in the thor_root instead of loading them all.
+  #
+  # By default, it also traverses the current path until find Bundler::Thor files, as
+  # described in thorfiles. This look up can be skipped by supplying
+  # skip_lookup true.
+  #
+  def initialize_thorfiles(relevant_to = nil, skip_lookup = false)
+    thorfiles(relevant_to, skip_lookup).each do |f|
+      Bundler::Thor::Util.load_thorfile(f, nil, options[:debug]) unless Bundler::Thor::Base.subclass_files.keys.include?(File.expand_path(f))
+    end
+  end
+
+  # Finds Thorfiles by traversing from your current directory down to the root
+  # directory of your system. If at any time we find a Bundler::Thor file, we stop.
+  #
+  # We also ensure that system-wide Thorfiles are loaded first, so local
+  # Thorfiles can override them.
+  #
+  # ==== Example
+  #
+  # If we start at /Users/wycats/dev/thor ...
+  #
+  # 1. /Users/wycats/dev/thor
+  # 2. /Users/wycats/dev
+  # 3. /Users/wycats <-- we find a Thorfile here, so we stop
+  #
+  # Suppose we start at c:\Documents and Settings\james\dev\thor ...
+  #
+  # 1. c:\Documents and Settings\james\dev\thor
+  # 2. c:\Documents and Settings\james\dev
+  # 3. c:\Documents and Settings\james
+  # 4. c:\Documents and Settings
+  # 5. c:\ <-- no Thorfiles found!
+  #
+  def thorfiles(relevant_to = nil, skip_lookup = false)
+    thorfiles = []
+
+    unless skip_lookup
+      Pathname.pwd.ascend do |path|
+        thorfiles = Bundler::Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
+        break unless thorfiles.empty?
+      end
+    end
+
+    files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Bundler::Thor::Util.thor_root_glob)
+    files += thorfiles
+    files -= ["#{thor_root}/thor.yml"]
+
+    files.map! do |file|
+      File.directory?(file) ? File.join(file, "main.thor") : file
+    end
+  end
+
+  # Load Thorfiles relevant to the given method. If you provide "foo:bar" it
+  # will load all thor files in the thor.yaml that has "foo" e "foo:bar"
+  # namespaces registered.
+  #
+  def thorfiles_relevant_to(meth)
+    lookup = [meth, meth.split(":")[0...-1].join(":")]
+
+    files = thor_yaml.select do |_, v|
+      v[:namespaces] && !(v[:namespaces] & lookup).empty?
+    end
+
+    files.map { |_, v| File.join(thor_root, (v[:filename]).to_s) }
+  end
+
+  # Display information about the given klasses. If with_module is given,
+  # it shows a table with information extracted from the yaml file.
+  #
+  def display_klasses(with_modules = false, show_internal = false, klasses = Bundler::Thor::Base.subclasses)
+    klasses -= [Bundler::Thor, Bundler::Thor::Runner, Bundler::Thor::Group] unless show_internal
+
+    raise Error, "No Bundler::Thor commands available" if klasses.empty?
+    show_modules if with_modules && !thor_yaml.empty?
+
+    list = Hash.new { |h, k| h[k] = [] }
+    groups = klasses.select { |k| k.ancestors.include?(Bundler::Thor::Group) }
+
+    # Get classes which inherit from Bundler::Thor
+    (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }
+
+    # Get classes which inherit from Bundler::Thor::Base
+    groups.map! { |k| k.printable_commands(false).first }
+    list["root"] = groups
+
+    # Order namespaces with default coming first
+    list = list.sort { |a, b| a[0].sub(/^default/, "") <=> b[0].sub(/^default/, "") }
+    list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
+  end
+
+  def display_commands(namespace, list) #:nodoc:
+    list.sort! { |a, b| a[0] <=> b[0] }
+
+    say shell.set_color(namespace, :blue, true)
+    say "-" * namespace.size
+
+    print_table(list, truncate: true)
+    say
+  end
+  alias_method :display_tasks, :display_commands
+
+  def show_modules #:nodoc:
+    info = []
+    labels = %w(Modules Namespaces)
+
+    info << labels
+    info << ["-" * labels[0].size, "-" * labels[1].size]
+
+    thor_yaml.each do |name, hash|
+      info << [name, hash[:namespaces].join(", ")]
+    end
+
+    print_table info
+    say ""
+  end
+end

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

@@ -0,0 +1,384 @@
+require_relative "column_printer"
+require_relative "table_printer"
+require_relative "wrapped_printer"
+
+class Bundler::Thor
+  module Shell
+    class Basic
+      attr_accessor :base
+      attr_reader   :padding
+
+      # Initialize base, mute and padding to nil.
+      #
+      def initialize #:nodoc:
+        @base = nil
+        @mute = false
+        @padding = 0
+        @always_force = false
+      end
+
+      # Mute everything that's inside given block
+      #
+      def mute
+        @mute = true
+        yield
+      ensure
+        @mute = false
+      end
+
+      # Check if base is muted
+      #
+      def mute?
+        @mute
+      end
+
+      # Sets the output padding, not allowing less than zero values.
+      #
+      def padding=(value)
+        @padding = [0, value].max
+      end
+
+      # 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
+
+      # 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 => "Neptune")
+      #
+      #   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)
+      #
+      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
+
+      # 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.")
+      #
+      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
+
+      # Say (print) an error 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_error("error: something went wrong")
+      #
+      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
+
+      # 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.
+      #
+      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
+
+      # Asks the user a question and returns true if the user replies "y" or
+      # "yes".
+      #
+      def yes?(statement, color = nil)
+        !!(ask(statement, color, add_to_history: false) =~ is?(:yes))
+      end
+
+      # Asks the user a question and returns true if the user replies "n" or
+      # "no".
+      #
+      def no?(statement, color = nil)
+        !!(ask(statement, color, add_to_history: false) =~ is?(:no))
+      end
+
+      # Prints values in columns
+      #
+      # ==== Parameters
+      # Array[String, String, ...]
+      #
+      def print_in_columns(array)
+        printer = ColumnPrinter.new(stdout)
+        printer.print(array)
+      end
+
+      # 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.
+      # borders<Boolean>:: Adds ascii borders.
+      #
+      def print_table(array, options = {}) # rubocop:disable Metrics/MethodLength
+        printer = TablePrinter.new(stdout, options)
+        printer.print(array)
+      end
+
+      # 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.
+      #
+      def print_wrapped(message, options = {})
+        printer = WrappedPrinter.new(stdout, options)
+        printer.print(message)
+      end
+
+      # 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
+      #
+      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(block_given?)
+          end
+        end
+      end
+
+      # 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.
+      #
+      def error(statement)
+        stderr.puts statement
+      end
+
+      # Apply color to the given string with optional bold. Disabled in the
+      # Bundler::Thor::Shell::Basic class.
+      #
+      def set_color(string, *) #:nodoc:
+        string
+      end
+
+    protected
+
+      def prepare_message(message, *color)
+        spaces = "  " * padding
+        spaces + set_color(message.to_s, *color)
+      end
+
+      def can_display_colors?
+        false
+      end
+
+      def lookup_color(color)
+        return color unless color.is_a?(Symbol)
+        self.class.const_get(color.to_s.upcase)
+      end
+
+      def stdout
+        $stdout
+      end
+
+      def stderr
+        $stderr
+      end
+
+      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 file_collision_help(block_given) #:nodoc:
+        help = <<-HELP
+        Y - yes, overwrite
+        n - no, do not overwrite
+        a - all, overwrite this and all others
+        q - quit, abort
+        h - help, show this help
+        HELP
+        if block_given
+          help << <<-HELP
+        d - diff, show the differences between the old and the new
+        m - merge, run merge tool
+          HELP
+        end
+        help
+      end
+
+      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), binmode: true) do |temp|
+          temp.write content
+          temp.rewind
+          system %(#{diff_cmd} "#{destination}" "#{temp.path}")
+        end
+      end
+
+      def quiet? #:nodoc:
+        mute? || (base && base.options[:quiet])
+      end
+
+      def unix?
+        Terminal.unix?
+      end
+
+      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 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 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 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:
+        @merge_tool ||= ENV["THOR_MERGE"] || "git difftool --no-index"
+      end
+    end
+  end
+end