cf 0.1.5 → 0.6.0.rc1

data/lib/cf/cli/command.rb

@@ -1,444 +0,0 @@
-require "thor"
-require "interact"
-require "yaml"
-
-require "cfoundry"
-
-require "cf/constants"
-require "cf/cli/dots"
-
-
-module CF
-  module Interactive
-    include ::Interactive::Rewindable
-    include Dots
-
-    class InteractiveDefault
-      def initialize(query)
-        @query = query
-      end
-
-      def to_s
-        "(interaction)"
-      end
-
-      def to_proc
-        @query
-      end
-    end
-
-    def force?
-      false
-    end
-
-    def ask(question, options = {})
-      if force? and options.key?(:default)
-        options[:default]
-      else
-        super
-      end
-    end
-
-    def list_choices(choices, options)
-      choices.each_with_index do |o, i|
-        puts "#{c(i + 1, :green)}: #{o}"
-      end
-    end
-
-    def input_state(options)
-      CFState.new(options)
-    end
-
-    def prompt(question, options)
-      value =
-        case options[:default]
-        when true
-          "y"
-        when false
-          "n"
-        when nil
-          ""
-        else
-          options[:default].to_s
-        end
-
-      print "#{question}"
-      print c("> ", :blue)
-
-      unless value.empty?
-        print "#{c(value, :black) + "\b" * value.size}"
-      end
-    end
-
-    def handler(which, state)
-      ans = state.answer
-      pos = state.position
-
-      if state.default?
-        if which.is_a?(Array) and which[0] == :key
-          # initial non-movement keypress clears default answer
-          clear_input(state)
-        else
-          # wipe away any coloring
-          redraw_input(state)
-        end
-
-        state.clear_default!
-      end
-
-      super
-
-      print "\n" if which == :enter
-    end
-
-    class CFState < Interactive::InputState
-      def initialize(options = {}, answer = nil, position = 0)
-        @options = options
-
-        if answer
-          @answer = answer
-        elsif options[:default]
-          case options[:default]
-          when true
-            @answer = "y"
-          when false
-            @answer = "n"
-          else
-            @answer = options[:default].to_s
-          end
-
-          @default = true
-        else
-          @answer = ""
-        end
-
-        @position = position
-        @done = false
-      end
-
-      def clear_default!
-        @default = false
-      end
-
-      def default?
-        @default
-      end
-    end
-  end
-
-  class Command < Thor
-    include Interactive
-
-    def self.flag(name, options = {}, &query)
-      if query
-        options[:default] ||= InteractiveDefault.new(query)
-      end
-
-      method_option(name, options)
-    end
-
-    def self.callbacks_for(name)
-      cs = callbacks[name]
-      if superclass.respond_to? :callbacks
-        cs.merge superclass.callbacks_for(name)
-      else
-        cs
-      end
-    end
-
-    def self.callbacks
-      @callbacks ||= Hash.new do |h, name|
-        h[name] = Hash.new do |h, task|
-          h[task] = []
-        end
-      end
-    end
-
-    def self.add_callback(name, task, callback)
-      callbacks[name][task] << callback
-    end
-
-    def self.before(task, &callback)
-      add_callback(:before, task, callback)
-    end
-
-    def self.after(task, &callback)
-      add_callback(:after, task, callback)
-    end
-
-    def self.ensuring(task, &callback)
-      add_callback(:ensuring, task, callback)
-    end
-
-    def self.around(task, &callback)
-      add_callback(:around, task, callback)
-    end
-
-    private
-
-    def callbacks_for(what)
-      self.class.callbacks_for(what)
-    end
-
-    def passed_value(flag)
-      if (val = options[flag]) && \
-          !val.is_a?(CF::Interactive::InteractiveDefault)
-        val
-      end
-    end
-
-    def input(name, *args)
-      @inputs ||= {}
-      return @inputs[name] if @inputs.key?(name)
-
-      if options[name].respond_to? :to_proc
-        @inputs[name] = instance_exec(*args, &options[name])
-      else
-        @inputs[name] = options[name]
-      end
-    end
-
-    def forget(name)
-      @inputs.delete name
-    end
-
-    def script?
-      if options.key?("script")
-        options["script"]
-      else
-        !$stdout.tty?
-      end
-    end
-
-    def force?
-      if options.key?("force")
-        options["force"]
-      else
-        script?
-      end
-    end
-
-    def simple_output?
-      if options.key?("simple_output")
-        options["simple_output"]
-      else
-        script?
-      end
-    end
-
-    def color?
-      if options.key?("color")
-        options["color"]
-      else
-        !simple_output?
-      end
-    end
-
-    def err(msg, exit_status = 1)
-      if script?
-        $stderr.puts(msg)
-      else
-        puts c(msg, :red)
-      end
-
-      $exit_status = 1
-    end
-
-    def invoke_task(task, args)
-      callbacks_for(:before)[task.name.to_sym].each do |c|
-        c.call
-      end
-
-      action = proc do |*new_args|
-        if new_args.empty?
-          task.run(self, args)
-        elsif new_args.first.is_a? Array
-          task.run(self, new_args.first)
-        else
-          task.run(self, new_args)
-        end
-      end
-
-      callbacks_for(:around)[task.name.to_sym].each do |a|
-        before = action
-        action = proc do |passed_args|
-          # with more than one wrapper, when the outer wrapper passes args to
-          # inner wrapper, which calls the next inner with no args, it should
-          # get the args passed to it by outer
-          args = passed_args if passed_args
-          instance_exec(before, args, &a)
-        end
-      end
-
-      res = instance_exec(args, &action)
-
-      callbacks_for(:after)[task.name.to_sym].each do |c|
-        c.call
-      end
-
-      res
-    rescue Interrupt
-      $exit_status = 130
-    rescue Thor::Error
-      raise
-    rescue Exception => e
-      msg = e.class.name
-      msg << ": #{e}" unless e.to_s.empty?
-      err msg
-
-      ensure_config_dir
-
-      File.open(File.expand_path(CF::CRASH_FILE), "w") do |f|
-        f.print "Time of crash:\n  "
-        f.puts Time.now
-        f.puts ""
-        f.puts msg
-        f.puts ""
-
-        e.backtrace.each do |loc|
-          if loc =~ /\/gems\//
-            f.puts loc.sub(/.*\/gems\//, "")
-          else
-            f.puts loc.sub(File.expand_path("../../../..", __FILE__) + "/", "")
-          end
-        end
-      end
-    ensure
-      callbacks_for(:ensuring)[task.name.to_sym].each do |c|
-        c.call
-      end
-    end
-    public :invoke_task
-
-    def sane_target_url(url)
-      unless url =~ /^https?:\/\//
-        url = "http://#{url}"
-      end
-
-      url.gsub(/\/$/, "")
-    end
-
-    def target_file
-      one_of(CF::TARGET_FILE, CF::OLD_TARGET_FILE)
-    end
-
-    def tokens_file
-      one_of(CF::TOKENS_FILE, CF::OLD_TOKENS_FILE)
-    end
-
-    def one_of(*paths)
-      paths.each do |p|
-        exp = File.expand_path(p)
-        return exp if File.exist? exp
-      end
-
-      paths.first
-    end
-
-    def client_target
-      File.read(target_file).chomp
-    end
-
-    def ensure_config_dir
-      config = File.expand_path(CF::CONFIG_DIR)
-      Dir.mkdir(config) unless File.exist? config
-    end
-
-    def set_target(url)
-      ensure_config_dir
-
-      File.open(File.expand_path(CF::TARGET_FILE), "w") do |f|
-        f.write(sane_target_url(url))
-      end
-
-      @client = nil
-    end
-
-    def tokens
-      new_toks = File.expand_path(CF::TOKENS_FILE)
-      old_toks = File.expand_path(CF::OLD_TOKENS_FILE)
-
-      if File.exist? new_toks
-        YAML.load_file(new_toks)
-      elsif File.exist? old_toks
-        JSON.load(File.read(old_toks))
-      else
-        {}
-      end
-    end
-
-    def client_token
-      tokens[client_target]
-    end
-
-    def save_tokens(ts)
-      ensure_config_dir
-
-      File.open(File.expand_path(CF::TOKENS_FILE), "w") do |io|
-        YAML.dump(ts, io)
-      end
-    end
-
-    def save_token(token)
-      ts = tokens
-      ts[client_target] = token
-      save_tokens(ts)
-    end
-
-    def remove_token
-      ts = tokens
-      ts.delete client_target
-      save_tokens(ts)
-    end
-
-    def client
-      return @client if @client
-
-      @client = CFoundry::Client.new(client_target, client_token)
-      @client.proxy = options[:proxy]
-      @client
-    end
-
-    def usage(used, limit)
-      "#{b(human_size(used))} of #{b(human_size(limit, 0))}"
-    end
-
-    def percentage(num, low = 50, mid = 70)
-      color =
-        if num <= low
-          :green
-        elsif num <= mid
-          :yellow
-        else
-          :red
-        end
-
-      c(format("%.1f\%", num), color)
-    end
-
-    def megabytes(str)
-      if str =~ /T$/i
-        str.to_i * 1024 * 1024
-      elsif str =~ /G$/i
-        str.to_i * 1024
-      elsif str =~ /M$/i
-        str.to_i
-      elsif str =~ /K$/i
-        str.to_i / 1024
-      end
-    end
-
-    def human_size(num, precision = 1)
-      sizes = ["G", "M", "K"]
-      sizes.each.with_index do |suf, i|
-        pow = sizes.size - i
-        unit = 1024 ** pow
-        if num >= unit
-          return format("%.#{precision}f%s", num / unit, suf)
-        end
-      end
-
-      format("%.#{precision}fB", num)
-    end
-  end
-end

data/lib/cf/cli/dots.rb

@@ -1,133 +0,0 @@
-module CF
-  module Dots
-    DOT_COUNT = 3
-    DOT_TICK = 0.15
-
-    class Skipper
-      def initialize(&ret)
-        @return = ret
-      end
-
-      def skip(&callback)
-        @return.call("SKIPPED", :yellow, callback)
-      end
-
-      def give_up(&callback)
-        @return.call("GAVE UP", :red, callback)
-      end
-
-      def fail(&callback)
-        @return.call("FAILED", :red, callback)
-      end
-    end
-
-    def with_progress(message)
-      unless simple_output?
-        print message
-        dots!
-      end
-
-      skipper = Skipper.new do |status, color, callback|
-        unless simple_output?
-          stop_dots!
-          puts "... #{c(status, color)}"
-        end
-
-        return callback && callback.call
-      end
-
-      begin
-        res = yield skipper
-        unless simple_output?
-          stop_dots!
-          puts "... #{c("OK", :green)}"
-        end
-        res
-      rescue
-        unless simple_output?
-          stop_dots!
-          puts "... #{c("FAILED", :red)}"
-        end
-
-        raise
-      end
-    end
-
-    def color?
-      $stdout.tty?
-    end
-
-    COLOR_CODES = {
-      :black => 0,
-      :red => 1,
-      :green => 2,
-      :yellow => 3,
-      :blue => 4,
-      :magenta => 5,
-      :cyan => 6,
-      :white => 7
-    }
-
-    # colored text
-    #
-    # shouldn't use bright colors, as some color themes abuse
-    # the bright palette (I'm looking at you, Solarized)
-    def c(str, color)
-      return str unless color?
-      "\e[3#{COLOR_CODES[color]}m#{str}\e[0m"
-    end
-    module_function :c
-
-    # bold text
-    def b(str)
-      return str unless color?
-      "\e[1m#{str}\e[0m"
-    end
-    module_function :b
-
-    def dots!
-      @dots ||=
-        Thread.new do
-          before_sync = $stdout.sync
-
-          $stdout.sync = true
-
-          printed = false
-          i = 1
-          until @stop_dots
-            if printed
-              print "\b" * DOT_COUNT
-            end
-
-            print ("." * i).ljust(DOT_COUNT)
-            printed = true
-
-            if i == DOT_COUNT
-              i = 0
-            else
-              i += 1
-            end
-
-            sleep DOT_TICK
-          end
-
-          if printed
-            print "\b" * DOT_COUNT
-            print " " * DOT_COUNT
-            print "\b" * DOT_COUNT
-          end
-
-          $stdout.sync = before_sync
-          @stop_dots = nil
-        end
-    end
-
-    def stop_dots!
-      return unless @dots
-      return if @stop_dots
-      @stop_dots = true
-      @dots.join
-      @dots = nil
-    end
-  end
-end