cf 0.1.0

data/lib/cf/cli/command.rb

@@ -0,0 +1,433 @@
+require "thor"
+require "interact"
+require "json/pure"
+
+require "conduit"
+
+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)
+      first = nil
+      paths.each do |p|
+        exp = File.expand_path(p)
+        first ||= exp
+        return exp if File.exist? exp
+      end
+
+      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
+      JSON.parse(File.read(tokens_file))
+    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 |f|
+        f.write ts.to_json
+      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
+      @client ||= Conduit::Client.new(client_target, client_token)
+    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

@@ -0,0 +1,130 @@
+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
+    def c(str, color, bright = true)
+      return str unless color?
+      "\e[#{bright ? 9 : 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