cloulu 0.0.0 → 0.1.1

data/lib/mothership/help/commands.rb

@@ -0,0 +1,53 @@
+require "mothership/help/printer"
+
+class Mothership
+  class << self
+    # add command to help group
+    def group(*names)
+      options =
+        if names.last.is_a? Hash
+          names.pop
+        else
+          {}
+        end
+
+      Mothership::Help.add_to_group(@command, names, options)
+    end
+  end
+
+  def default_action
+    invoke :help
+  end
+
+  def unknown_command(name)
+    $stderr.print "Unknown command '#{name.to_s.gsub("_", "-")}'. "
+    $stderr.puts "See 'help' for available commands."
+    exit_status 1
+  end
+
+  desc "Help!"
+  input :command, :argument => :optional
+  input :all, :type => :boolean
+  def help
+    # custom header
+    puts "\x1B[1m\x1B[33m===========================================================\x1B[00m"
+    puts "\x1B[1m\x1B[33m* Welcome Cloulu Platform\x1B[00m"
+    puts "\x1B[1m\x1B[33m*\x1B[00m"
+    puts "\x1B[1m\x1B[33m* @author clouluteam <cloulu@sk.com>\x1B[00m"
+    puts "\x1B[1m\x1B[33m* @homepage https://cloulu.com, http://blog.cloulu.com\x1B[00m"
+    puts "\x1B[1m\x1B[33m============================================================\x1B[00m"
+    puts
+    
+    if name = input[:command]
+      if cmd = @@commands[name.gsub("-", "_").to_sym]
+        Mothership::Help.command_help(cmd)
+      else
+        unknown_command(name)
+      end
+    elsif Help.has_groups?
+      Mothership::Help.print_help_groups(@@global, input[:all])
+    else
+      Mothership::Help.basic_help(@@commands, @@global)
+    end
+  end
+end

data/lib/mothership/help/printer.rb

@@ -0,0 +1,170 @@
+module Mothership::Help
+  class << self
+    def print_help_groups(global = nil, all = false)
+      @@groups.each do |commands|
+        print_help_group(commands, all)
+      end
+
+      command_options(global)
+    end
+
+    def print_help_group(group, all = false, indent = 0)
+      return if nothing_printable?(group, all)
+
+      members = group[:members]
+
+      unless all
+        members = members.reject do |_, opts|
+          opts[:hidden]
+        end
+      end
+
+      commands = members.collect(&:first)
+
+      i = "   " * indent
+
+      # set prefix
+      prefix = "*"
+      prefix = ">>" if indent == 1
+
+      # set color
+      color = "31"
+      color = "32" if indent == 1
+
+      print i
+      puts "\x1B[1m\x1B[#{color}m" + prefix + " " + group[:description] + "\x1B[00m"
+
+      commands = unique_commands(commands)
+
+      width = 0
+      commands.each do |cmd|
+        len = cmd.usage.size
+        if len > width
+          width = len
+        end
+      end
+
+      commands.each do |cmd|
+        puts "#{i}  #{cmd.usage.ljust(width)}\t#{cmd.description}"
+      end
+
+      puts "" unless commands.empty?
+
+      group[:children].each do |group|
+        print_help_group(group, all, indent + 1)
+      end
+    end
+
+    def basic_help(commands, global)
+      puts "Commands:"
+
+      width = 0
+      commands.each do |_, c|
+        len = c.usage.size
+        width = len if len > width
+      end
+
+      commands.each do |_, c|
+        puts "  #{c.usage.ljust(width)}\t#{c.description}"
+      end
+
+      unless global.flags.empty?
+        puts ""
+        command_options(global)
+      end
+    end
+
+    def command_help(cmd)
+      puts cmd.description
+      puts ""
+      command_usage(cmd)
+    end
+
+    def command_usage(cmd, io = $stdout)
+      io.puts "Usage: #{cmd.usage}"
+
+      unless cmd.flags.empty?
+        io.puts ""
+        command_options(cmd, io)
+      end
+    end
+
+    def command_options(cmd, io = $stdout)
+      io.puts "Options:"
+
+      rev_flags = Hash.new { |h, k| h[k] = [] }
+
+      cmd.flags.each do |f, n|
+        rev_flags[n] << f
+      end
+
+      usages = []
+
+      max_width = 0
+      rev_flags.collect do |name, fs|
+        info = cmd.inputs[name]
+        next if info[:hidden]
+
+        flag = name.to_s.gsub("_", "-")
+
+        # move full form to the front
+        fs.unshift fs.delete("--#{flag}")
+
+        if short = fs.find { |x| x =~ /^-.$/ }
+          fs.delete short
+        end
+
+        if info[:type] == :boolean && info[:default]
+          fs[0] = "--[no-]#{flag}"
+        end
+
+        if info.key?(:default) && info.key?(:interact)
+          fs.unshift "--ask-#{flag}"
+        end
+
+        usage = "#{short ? short + "," : "   "} #{fs.join ", "}"
+
+        unless info[:type] == :boolean
+          usage << " #{(info[:value] || name).to_s.upcase}"
+        end
+
+        max_width = usage.size if usage.size > max_width
+
+        usages << [usage, info[:description]]
+      end
+
+      usages.sort! { |a, b| a.first <=> b.first }
+
+      usages.each do |u, d|
+        if d
+          io.puts "  #{u.ljust(max_width)}    #{d}"
+        else
+          io.puts "  #{u}"
+        end
+      end
+    end
+
+    private
+
+    def nothing_printable?(group, all = false)
+      group[:members].reject { |_, opts| !all && opts[:hidden] }.empty? &&
+        group[:children].all? { |g| nothing_printable?(g) }
+    end
+
+    def unique_commands(commands)
+      uniq_commands = []
+      cmd_index = {}
+
+      commands.each do |cmd|
+        if idx = cmd_index[cmd.name]
+          uniq_commands[idx] = cmd
+        else
+          cmd_index[cmd.name] = uniq_commands.size
+          uniq_commands << cmd
+        end
+      end
+
+      uniq_commands
+    end
+  end
+end

data/lib/mothership/help.rb

@@ -0,0 +1,64 @@
+require "mothership/base"
+require "mothership/help/commands"
+
+module Mothership::Help
+  @@groups = []
+  @@tree = {}
+
+  class << self
+    def has_groups?
+      !@@groups.empty?
+    end
+
+    # define help groups
+    def groups(*tree)
+      tree.each do |*args|
+        add_group(@@groups, @@tree, *args.first)
+      end
+    end
+
+    def group(*names)
+      if where = find_group(names, @@tree)
+        where[:members].collect(&:first)
+      else
+        []
+      end
+    end
+
+    def add_to_group(command, names, options)
+      where = find_group(names, @@tree)
+      raise "unknown help group: #{names.join("/")}" unless where
+      
+      where[:members] << [command, options]
+    end
+
+    private
+
+    def find_group(names, where)
+      names.each_with_index do |n, index|
+        where = where[:children] unless index == 0
+        break unless where
+
+        where = where[n]
+        break unless where
+      end
+
+      where
+    end
+
+    def add_group(groups, tree, name, desc, *subs)
+      members = []
+
+      meta = { :members => members, :children => [] }
+      groups << meta
+
+      tree[name] = { :members => members, :children => {} }
+
+      meta[:description] = desc
+
+      subs.each do |*args|
+        add_group(meta[:children], tree[name][:children], *args.first)
+      end
+    end
+  end
+end

data/lib/mothership/inputs.rb

@@ -0,0 +1,189 @@
+class Mothership
+  class Inputs
+    attr_reader :inputs, :given, :global
+
+    # the input being processed; set during #get
+    attr_reader :current_input
+
+    def initialize(
+        command, context = nil,
+        inputs = {}, given = {}, global = {})
+      @command = command
+      @context = context
+      @inputs = inputs
+      @given = given
+      @global = global
+    end
+
+    def has?(name)
+      @inputs.key?(name) || @given.key?(name)
+    end
+
+    def direct(name)
+      if @inputs.key?(name)
+        @inputs[name]
+      elsif (given = @given[name]) != :interact
+        given
+      end
+    end
+
+    def merge(inputs)
+      self.class.new(@command, @context, @inputs.merge(inputs), @given, @global)
+    end
+
+    def merge_given(given)
+      self.class.new(@command, @context, @inputs.dup, @given.merge(given), @global)
+    end
+
+    def rebase(inputs)
+      self.class.new(@command, @context, inputs.merge(@inputs), @given, @global)
+    end
+
+    def rebase_given(given)
+      self.class.new(@command, @context, @inputs.dup, given.merge(@given), @global)
+    end
+
+    def without(*names)
+      given = @given.dup
+      inputs = @inputs.dup
+      names.each do |n|
+        given.delete(n)
+        inputs.delete(n)
+      end
+
+      self.class.new(@command, @context, inputs, given, @global)
+    end
+
+    def [](name, *args)
+      return @inputs[name] if @inputs.key?(name)
+
+      if @command && meta = @command.inputs[name]
+        # special case so #invoke can be called with singular-named inputs
+        singular = meta[:singular]
+
+        if @inputs.key?(singular)
+          return @inputs[name] = [@inputs[singular]]
+        end
+      end
+
+      found, val = get(name, @context, *args)
+
+      @inputs[name] = val unless meta && meta[:forget]
+
+      val
+    end
+
+    def interact(name, context, *args)
+      meta =
+        if @command
+          @command.inputs[name]
+        else
+          Mothership.global_option(name)
+        end
+
+      interact = meta[:interact] || :"ask_#{name}"
+
+      case interact
+      when Symbol, String
+        context.send(interact, *args)
+      else
+        context.instance_exec(*args, &interact)
+      end
+    end
+
+    # search:
+    # 1. cache
+    # 2. cache, singular
+    # 3. given
+    # 4. given, singular
+    # 5. global
+    # 6. global, singular
+    def get(name, context, *args)
+      before_input = @current_input
+      @current_input = [name, args]
+
+      if @command && meta = @command.inputs[name]
+        found, val = find_in(@given, name, meta, context, *args)
+      elsif @global.is_a?(self.class)
+        return @global.get(name, context, *args)
+      elsif @global.key?(name)
+        return [true, @global[name]]
+      end
+
+      return [false, val] if not found
+
+      if val == :interact
+        [true, interact(name, context, *args)]
+      else
+        [true, convert_given(meta, context, val, *args)]
+      end
+    ensure
+      @current_input = before_input
+    end
+
+    def forget(name)
+      @inputs.delete(name)
+      @given.delete(name)
+    end
+
+    def interactive?(name)
+      @given[name] == :interact
+    end
+
+    private
+
+    def find_in(where, name, meta, context, *args)
+      singular = meta[:singular]
+
+      if where.key?(name)
+        [true, where[name]]
+      elsif where.key?(singular)
+        [true, [where[singular]]]
+      else
+        # no value given; set as default
+        [false, default_for(name, meta, context, *args)]
+      end
+    end
+
+    def convert_given(meta, context, given, *args)
+      if convert = meta[:from_given]
+        if given.is_a?(Array)
+          given.collect do |i|
+            context.instance_exec(i, *args, &convert)
+          end
+        else
+          context.instance_exec(given, *args, &convert)
+        end
+      else
+        case meta[:type]
+        when :integer, :number, :numeric
+          given.to_i
+        when :float, :floating
+          given.to_f
+        when :bool, :boolean
+          given == "true"
+        else
+          given
+        end
+      end
+    end
+
+    def default_for(name, meta, context, *args)
+      if meta.key?(:default)
+        default = meta[:default]
+
+        if default.respond_to? :to_proc
+          context.instance_exec(*args, &default)
+        else
+          default
+        end
+      elsif meta[:interact] || context.respond_to?(:"ask_#{name}", true)
+        interact(name, context, *args)
+      elsif meta[:type] == :boolean
+        false
+      elsif meta[:argument] == :splat
+        []
+      end
+    end
+  end
+end

data/lib/mothership/parser.rb

@@ -0,0 +1,182 @@
+class Mothership
+  class Parser
+    attr_reader :given
+
+    def initialize(command, given = {})
+      @command = command
+      @given = given
+    end
+
+    def parse_argv(argv)
+      args = parse_flags(argv.dup)
+
+      parse_arguments(args)
+
+      @given
+    end
+
+    def parse_flags(argv, find_in = nil)
+      local = nil
+      args = []
+
+      until argv.empty?
+        flag = normalize_flag(argv.shift, argv)
+
+        name = local && local.flags[flag] || @command.flags[flag]
+        unless name
+          # assume first argument is subcommand
+          if args.empty? && find_in && !local
+            local = find_in[flag.gsub("-", "_").to_sym]
+          end
+
+          args << flag
+          next
+        end
+
+        # skip flags defined by the local cmd
+        if local && local.inputs[name]
+          args << flag
+          next
+        end
+
+        input = @command.inputs[name]
+
+        if argv.first == "--ask"
+          @given[name] = :interact
+          argv.shift
+          next
+        end
+
+        case input[:type]
+        when :bool, :boolean
+          if argv.first == "false" || argv.first == "true"
+            @given[name] = argv.shift
+          else
+            @given[name] = "true"
+          end
+        when :float, :floating
+          if !argv.empty? && argv.first =~ /^[0-9]+(\.[0-9]*)?$/
+            @given[name] = argv.shift
+          else
+            raise TypeMismatch.new(@command, name, "floating")
+          end
+        when :integer, :number, :numeric
+          if !argv.empty? && argv.first =~ /^[0-9]+$/
+            @given[name] = argv.shift
+          else
+            raise TypeMismatch.new(@command, name, "numeric")
+          end
+        else
+          arg =
+            if argv.empty? || argv.first.start_with?("-")
+              ""
+            else
+              argv.shift
+            end
+
+          @given[name] =
+            if input[:argument] == :splat
+              arg.split(",")
+            else
+              arg
+            end
+        end
+      end
+
+      args
+    end
+
+    # [FOO] [BAR] FIZZ BUZZ:
+    #   1 2 => :fizz => 1, :buzz => 2
+    #   1 2 3 => :foo => 1, :fizz => 2, :buzz => 3
+    #   1 2 3 4 => :foo => 1, :bar => 2, :fizz => 3, :buzz => 4
+    def parse_arguments(args)
+      total = @command.arguments.size
+      required = 0
+      optional = 0
+      @command.arguments.each do |arg|
+        case arg[:type]
+        when :optional
+          optional += 1
+        when :splat
+          break
+        else
+          required += 1
+        end
+      end
+
+      parse_optionals = args.size - required
+
+      @command.arguments.each do |arg|
+        name = arg[:name]
+        next if @given.key? name
+
+        input = @command.inputs[name]
+
+        case arg[:type]
+        when :splat
+          @given[name] = []
+
+          until args.empty?
+            @given[name] << args.shift
+          end
+
+        when :optional
+          if parse_optionals > 0 && val = args.shift
+            @given[name] = val
+            parse_optionals -= 1
+          end
+
+        else
+          if val = args.shift
+            @given[name] = val
+          elsif !input[:default] && !input[:interact]
+            raise MissingArgument.new(@command, name)
+          end
+        end
+      end
+
+      raise ExtraArguments.new(@command, args) unless args.empty?
+    end
+
+    private
+
+    # --no-foo => --foo false
+    # --no-foo true => --foo false
+    # --no-foo false => --foo true
+    #
+    # --foo=bar => --foo bar
+    def normalize_flag(flag, argv)
+      case flag
+      # boolean negation
+      when /^--no-(.+)/
+        case argv.first
+        when "true"
+          argv[0] = "false"
+        when "false"
+          argv[0] = "true"
+        else
+          argv.unshift "false"
+        end
+
+        "--#$1"
+
+      when /^--ask-(.+)/
+        argv.unshift "--ask"
+        "--#$1"
+
+      # --foo=bar form
+      when /^--([^=]+)=(.+)/
+        argv.unshift $2
+        "--#$1"
+
+      # normal flag name
+      when /^--([^ ]+)$/
+        "--#$1"
+
+      else
+        flag
+      end
+    end
+  end
+end

data/lib/mothership/version.rb

@@ -0,0 +1,3 @@
+class Mothership
+  VERSION = "0.5.1"
+end