mothership 0.0.1

data/lib/mothership/parser.rb

@@ -0,0 +1,154 @@
+class Mothership
+  class Parser
+    def initialize(command)
+      @command = command
+    end
+
+    def inputs(argv)
+      inputs = {}
+
+      args = parse_flags(inputs, argv.dup)
+
+      parse_arguments(inputs, args)
+
+      inputs
+    end
+
+    def parse_flags(inputs, argv)
+      args = []
+
+      until argv.empty?
+        flag = normalize_flag(argv.shift, argv)
+
+        name = @command.flags[flag]
+        unless name
+          args << flag
+          next
+        end
+
+        input = @command.inputs[name]
+
+        case input[:type]
+        when :bool, :boolean
+          if argv.first == "false" || argv.first == "true"
+            inputs[name] = argv.shift == "true"
+          else
+            inputs[name] = true
+          end
+        when :float, :floating
+          if !argv.empty? && argv.first =~ /^[0-9]+(\.[0-9]*)?$/
+            inputs[name] = argv.shift.to_f
+          else
+            raise TypeMismatch.new(@command.name, name, "floating")
+          end
+        when :integer, :number, :numeric
+          if !argv.empty? && argv.first =~ /^[0-9]+$/
+            inputs[name] = argv.shift.to_i
+          else
+            raise TypeMismatch.new(@command.name, name, "numeric")
+          end
+        else
+          if argv.empty? || !argv.first.start_with?("-")
+            arg = argv.shift || ""
+
+            inputs[name] =
+              if input[:argument] == :splat
+                arg.split(",")
+              else
+                arg
+              end
+          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(inputs, 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 inputs.key? name
+
+        case arg[:type]
+        when :splat
+          inputs[name] = []
+
+          until args.empty?
+            inputs[name] << args.shift
+          end
+
+        when :optional
+          if parse_optionals > 0 && val = args.shift
+            inputs[name] = val
+            parse_optionals -= 1
+          end
+
+        else
+          if val = args.shift
+            inputs[name] = val
+          elsif !@command.inputs[name][:default]
+            raise MissingArgument.new(@command.name, name)
+          end
+        end
+      end
+
+      raise ExtraArguments.new(@command.name) 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"
+
+      # --foo=bar form
+      when /^--([^=]+)=(.+)/
+        argv.unshift $2
+        "--#$1"
+
+      # normal flag name
+      when /^--([^ ]+)$/
+        "--#$1"
+
+      else
+        flag
+      end
+    end
+  end
+end

data/lib/mothership/pretty.rb

@@ -0,0 +1,82 @@
+require "rbconfig"
+
+# Mix in to your Mothership class to enable user-toggleable colors.
+#
+# Redefine color_enabled? to control color enabling/disabling. Colors will be
+# auto-disabled if the platform is Windows or if $stdout is not a tty.
+#
+# Redefine user_colors to return a hash from tags to color, e.g. from a user's
+# color config file.
+module Mothership::Pretty
+  WINDOWS = !!(RbConfig::CONFIG['host_os'] =~ /mingw|mswin32|cygwin/)
+
+  COLOR_CODES = {
+    :black => 0,
+    :red => 1,
+    :green => 2,
+    :yellow => 3,
+    :blue => 4,
+    :magenta => 5,
+    :cyan => 6,
+    :white => 7
+  }
+
+  DEFAULT_COLORS = {
+    :name => :blue,
+    :neutral => :blue,
+    :good => :green,
+    :bad => :red,
+    :error => :magenta,
+    :unknown => :cyan,
+    :warning => :yellow,
+    :instance => :yellow,
+    :number => :green,
+    :prompt => :blue,
+    :yes => :green,
+    :no => :red,
+    :dim => :black,
+    :default => :black
+  }
+
+  private
+
+  # override with e.g. option(:color), or whatever toggle you use
+  def color_enabled?
+    true
+  end
+
+  # use colors?
+  def color?
+    color_enabled? && !WINDOWS && $stdout.tty?
+  end
+
+  # redefine to control the tag -> color settings
+  def user_colors
+    DEFAULT_COLORS
+  end
+
+  # colored text
+  #
+  # shouldn't use bright colors, as some color themes abuse
+  # the bright palette (I'm looking at you, Solarized)
+  def c(str, type)
+    return str unless color?
+
+    bright = false
+    color = user_colors[type]
+    if color =~ /bright-(.+)/
+      bright = true
+      color = $1.to_sym
+    end
+
+    return str unless color
+
+    "\e[#{bright ? 9 : 3}#{COLOR_CODES[color]}m#{str}\e[0m"
+  end
+
+  # bold text
+  def b(str)
+    return str unless color?
+    "\e[1m#{str}\e[0m"
+  end
+end

data/lib/mothership/progress.rb

@@ -0,0 +1,112 @@
+require "mothership/pretty"
+
+module Mothership::Progress
+  include Mothership::Pretty
+
+  module Dots
+    class << self
+      DOT_COUNT = 3
+      DOT_TICK = 0.15
+
+      def start!
+        @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!
+        return unless @dots
+        return if @stop_dots
+        @stop_dots = true
+        @dots.join
+        @dots = nil
+      end
+    end
+  end
+
+  class Skipper
+    def initialize(&ret)
+      @return = ret
+    end
+
+    def skip(&callback)
+      @return.call("SKIPPED", :warning, callback)
+    end
+
+    def give_up(&callback)
+      @return.call("GAVE UP", :bad, callback)
+    end
+
+    def fail(&callback)
+      @return.call("FAILED", :error, callback)
+    end
+  end
+
+  # override to determine whether to show progress
+  def quiet?
+    false
+  end
+
+  def with_progress(message)
+    unless quiet?
+      print message
+      Dots.start!
+    end
+
+    skipper = Skipper.new do |status, color, callback|
+      unless quiet?
+        Dots.stop!
+        puts "... #{c(status, color)}"
+      end
+
+      return callback && callback.call
+    end
+
+    begin
+      res = yield skipper
+      unless quiet?
+        Dots.stop!
+        puts "... #{c("OK", :good)}"
+      end
+      res
+    rescue
+      unless quiet?
+        Dots.stop!
+        puts "... #{c("FAILED", :error)}"
+      end
+
+      raise
+    end
+  end
+end

data/lib/mothership/version.rb

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

data/lib/mothership.rb

@@ -0,0 +1,66 @@
+require "mothership/base"
+require "mothership/callbacks"
+require "mothership/command"
+require "mothership/parser"
+require "mothership/help"
+require "mothership/errors"
+
+class Mothership
+  # [Mothership::Command] global options
+  @@global = Command.new(self, "(global options)")
+
+  # [Mothershp::Inputs] inputs from global options
+  @@inputs = nil
+
+  # [Fixnum] exit status; reassign as appropriate error code (e.g. 1)
+  @@exit_status = 0
+
+  class << self
+    # define a global option
+    def option(name, options = {}, &default)
+      @@global.add_input(name, options, &default)
+    end
+
+    # parse argv, by taking the first arg as the command, and the rest as
+    # arguments and flags
+    #
+    # arguments and flags can be in any order; all flags will be parsed out
+    # first, and the bits left over will be treated as arguments
+    def start(argv)
+      @@inputs = Inputs.new(@@global, self, {})
+
+      name, *argv =
+        Parser.new(@@global).parse_flags(
+          @@inputs.inputs,
+          argv)
+
+      app = new
+
+      return app.default_action unless name
+
+      cmdname = name.gsub("-", "_").to_sym
+
+      cmd = @@commands[cmdname]
+      return app.unknown_command(cmdname) unless cmd
+
+      app.execute(cmd, argv)
+
+      exit @@exit_status
+    end
+  end
+
+  # set the exit status
+  def exit_status(num)
+    @@exit_status = num
+  end
+
+  # get value of global option
+  def option(name, *args)
+    @@inputs[name, *args]
+  end
+
+  # test if an option was explicitly provided
+  def option_given?(name)
+    @@inputs.given? name
+  end
+end

data/spec/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default, :development)
+
+require 'rake/dsl_definition'
+require 'rake'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "**/*_spec.rb"
+  t.rspec_opts = ["--format", "documentation", "--colour"]
+end
+

data/spec/arguments_spec.rb

@@ -0,0 +1,164 @@
+require "mothership"
+require "./helpers"
+
+describe Mothership::Parser do
+  describe "arguments" do
+    describe "normal" do
+      it "is declared as an input" do
+        command(:foo => { :argument => true }) do |c|
+          inputs(c, "bar").should == { :foo => "bar" }
+        end
+      end
+
+      it "can be passed as a flag" do
+        command(:foo => { :argument => true }) do |c|
+          inputs(c, "--foo", "bar").should == { :foo => "bar" }
+        end
+      end
+
+      it "is parsed in the order of definition" do
+        command([
+            [:foo, { :argument => true }],
+            [:bar, { :argument => true }]]) do |c|
+          inputs(c, "fizz", "buzz").should ==
+            { :foo => "fizz", :bar => "buzz" }
+        end
+
+        command([
+            [:bar, { :argument => true }],
+            [:foo, { :argument => true }]]) do |c|
+          inputs(c, "fizz", "buzz").should ==
+            { :foo => "buzz", :bar => "fizz" }
+        end
+      end
+    end
+
+    describe "optional & required ordering" do
+      it "parses required arguments positioned before optionals first" do
+        command([
+            [:foo, { :argument => true }],
+            [:foo2, { :argument => true }],
+            [:bar, { :argument => :optional }],
+            [:bar2, { :argument => :optional }]]) do |c|
+          inputs(c, "a", "b").should == { :foo => "a", :foo2 => "b" }
+
+          inputs(c, "a", "b", "c").should ==
+            { :foo => "a", :foo2 => "b", :bar => "c" }
+
+          inputs(c, "a", "b", "c", "d").should ==
+            { :foo => "a", :foo2 => "b", :bar => "c", :bar2 => "d" }
+        end
+      end
+
+      it "parses required arguments positioned after optionals first " do
+        command([
+            [:foo, { :argument => :optional }],
+            [:foo2, { :argument => :optional }],
+            [:bar, { :argument => true }],
+            [:bar2, { :argument => true }]]) do |c|
+          inputs(c, "a", "b").should == { :bar => "a", :bar2 => "b" }
+
+          inputs(c, "a", "b", "c").should ==
+            { :bar => "b", :bar2 => "c", :foo => "a" }
+
+          inputs(c, "a", "b", "c", "d").should ==
+            { :bar => "c", :bar2 => "d", :foo => "a", :foo2 => "b" }
+        end
+      end
+
+      it "parses required arguments positioned around optionals first " do
+        command([
+            [:foo, { :argument => true }],
+            [:foo2, { :argument => :optional }],
+            [:bar, { :argument => :optional }],
+            [:bar2, { :argument => true }]]) do |c|
+          inputs(c, "a", "b").should == { :foo => "a", :bar2 => "b" }
+
+          inputs(c, "a", "b", "c").should ==
+            { :foo => "a", :foo2 => "b", :bar2 => "c" }
+
+          inputs(c, "a", "b", "c", "d").should ==
+            { :foo => "a", :foo2 => "b", :bar => "c", :bar2 => "d" }
+        end
+      end
+
+      it "parses required arguments positioned between optionals first " do
+        command([
+            [:foo, { :argument => :optional }],
+            [:foo2, { :argument => true }],
+            [:bar, { :argument => true }],
+            [:bar2, { :argument => :optional }]]) do |c|
+          inputs(c, "a", "b").should == { :foo2 => "a", :bar => "b" }
+
+          inputs(c, "a", "b", "c").should ==
+            { :foo => "a", :foo2 => "b", :bar => "c" }
+
+          inputs(c, "a", "b", "c", "d").should ==
+            { :foo => "a", :foo2 => "b", :bar => "c", :bar2 => "d" }
+        end
+      end
+    end
+
+    describe "as flags" do
+      it "assigns as the value if given" do
+        command(:foo => { :argument => true }) do |c|
+          inputs(c, "--foo", "bar").should == { :foo => "bar" }
+        end
+      end
+
+      it "assigns as an empty string if just name is given" do
+        command(:foo => { :argument => true }) do |c|
+          inputs(c, "--foo").should == { :foo => "" }
+        end
+      end
+    end
+
+    describe "splats" do
+      it "is declared as an input" do
+        command(:foo => { :argument => :splat }) do |c|
+          inputs(c, "bar").should == { :foo => ["bar"] }
+        end
+      end
+
+      it "assigns as an empty array if no arguments given" do
+        command(:foo => { :argument => :splat }) do |c|
+          inputs(c).should == { :foo => [] }
+        end
+      end
+
+      it "assigns as an array if one argument given" do
+        command(:foo => { :argument => :splat }) do |c|
+          inputs(c, "foo").should == { :foo => ["foo"] }
+        end
+      end
+
+      it "assigns as an array if two or more arguments given" do
+        command(:foo => { :argument => :splat }) do |c|
+          inputs(c, "foo", "bar").should == { :foo => ["foo", "bar"] }
+          inputs(c, "foo", "bar", "baz").should ==
+            { :foo => ["foo", "bar", "baz"] }
+        end
+      end
+
+      describe "as flags" do
+        it "assigns as an empty array if just name is given" do
+          command(:foo => { :argument => :splat }) do |c|
+            inputs(c, "--foo").should == { :foo => [] }
+          end
+        end
+
+        it "assigns as an array if one value given" do
+          command(:foo => { :argument => :splat }) do |c|
+            inputs(c, "--foo", "bar").should == { :foo => ["bar"] }
+          end
+        end
+
+        it "accepts comma-separated values" do
+          command(:foo => { :argument => :splat }) do |c|
+            inputs(c, "--foo", "bar,baz").should == { :foo => ["bar", "baz"] }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/combination_spec.rb

@@ -0,0 +1,105 @@
+require "mothership"
+require "./helpers"
+
+describe Mothership::Parser do
+  describe "combinations" do
+    describe "arguments & flags" do
+      it "parses flags placed after arguments" do
+        command(:flag => {}, :arg => { :argument => true }) do |c|
+          inputs(c, "foo", "--flag", "bar").should ==
+            { :arg => "foo", :flag => "bar" }
+        end
+      end
+
+      it "parses flags placed before arguments" do
+        command(:flag => {}, :arg => { :argument => true }) do |c|
+          inputs(c, "--flag", "bar", "foo").should ==
+            { :arg => "foo", :flag => "bar" }
+        end
+      end
+
+      it "parses flags placed between arguments" do
+        command([
+            [:flag, {}],
+            [:arg1, { :argument => true }],
+            [:arg2, { :argument => true }]]) do |c|
+          inputs(c, "foo", "--flag", "bar", "baz").should ==
+            { :arg1 => "foo", :flag => "bar", :arg2 => "baz" }
+        end
+      end
+
+      it "skips parsing arguments that were passed as flags" do
+        command([
+            [:arg1, { :argument => true }],
+            [:arg2, { :argument => true }]]) do |c|
+          inputs(c, "baz", "--arg1", "foo").should ==
+            { :arg1 => "foo", :arg2 => "baz" }
+        end
+      end
+    end
+
+    describe "arguments & splats" do
+      it "consumes the rest of the arguments" do
+        command([
+            [:foo, { :argument => :splat }],
+            [:bar, { :argument => true }]]) do |c|
+          proc {
+            inputs(c, "fizz", "buzz")
+          }.should raise_error(Mothership::MissingArgument)
+        end
+      end
+
+      it "consumes arguments after normal arguments" do
+        command([
+            [:foo, { :argument => true }],
+            [:bar, { :argument => :splat }]]) do |c|
+          inputs(c, "fizz", "buzz").should ==
+            { :foo => "fizz", :bar => ["buzz"] }
+        end
+      end
+
+      it "appears empty when there are no arguments left after normal" do
+        command([
+            [:foo, { :argument => true }],
+            [:bar, { :argument => :splat }]]) do |c|
+          inputs(c, "fizz").should ==
+            { :foo => "fizz", :bar => [] }
+        end
+      end
+    end
+
+    describe "splats & flags" do
+      it "parses flags placed after splats" do
+        command(:flag => {}, :arg => { :argument => :splat }) do |c|
+          inputs(c, "foo", "--flag", "bar").should ==
+            { :arg => ["foo"], :flag => "bar" }
+        end
+      end
+
+      it "parses flags placed before splats" do
+        command(:flag => {}, :arg => { :argument => :splat }) do |c|
+          inputs(c, "--flag", "bar", "foo").should ==
+            { :arg => ["foo"], :flag => "bar" }
+        end
+      end
+
+      it "parses flags placed between splat arguments" do
+        command([
+            [:flag, {}],
+            [:arg, { :argument => :splat }]]) do |c|
+          inputs(c, "foo", "--flag", "bar", "baz").should ==
+            { :arg => ["foo", "baz"], :flag => "bar" }
+        end
+      end
+
+      it "skips parsing splats that were passed as flags" do
+        command([
+            [:arg1, { :argument => :splat }],
+            [:arg2, { :argument => true }]]) do |c|
+          inputs(c, "baz", "--arg1", "foo").should ==
+            { :arg1 => ["foo"], :arg2 => "baz" }
+        end
+      end
+    end
+  end
+end