Enhanced option parsing with new getopt and made rebar more user friendly

src/getopt.erl

@@ -11,6 +11,9 @@
 -module(getopt).
 -author('juanjo@comellas.org').
 
+-export([parse/2, usage/2]).
+
+
 -define(TAB_LENGTH, 8).
 %% Indentation of the help messages in number of tabs.
 -define(INDENTATION, 3).
@@ -44,8 +47,6 @@
                    Help    :: string() | undefined
                   }.
 
--export([parse/2, usage/2]).
-
 
 -spec parse([option_spec()], string() | [string()]) -> {ok, {[option()], [string()]}} | {error, {Reason :: atom(), Data :: any()}}.
 %%--------------------------------------------------------------------
@@ -71,12 +72,20 @@ parse(OptSpecList, CmdLine) ->
 -spec parse([option_spec()], [option()], [string()], integer(), [string()]) ->
     {ok, {[option()], [string()]}} | {error, {Reason :: atom(), Data:: any()}}.
 %% Process long options.
-parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [[$-, $- | LongName] = OptStr | Tail]) ->
+parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [[$-, $- | Name] = OptStr | Tail]) ->
-    {Option, Tail1} = get_option(OptSpecList, OptStr, LongName, ?OPT_LONG, Tail),
+    {Option, Tail1} = 
+        case split_embedded_arg(Name) of
+            {Name1, Arg} ->
+                %% Get option that has its argument within the same string
+                %% separated by an equal ('=') character.
+                {get_option_embedded_arg(OptSpecList, OptStr, ?OPT_LONG, Name1, Arg), Tail};
+            _Name1 ->
+                get_option(OptSpecList, OptStr, ?OPT_LONG, Name, Tail)
+        end,
     parse(OptSpecList, [Option | OptAcc], ArgAcc, ArgPos, Tail1);
 %% Process short options.
 parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [[$-, ShortName] = OptStr | Tail]) ->
-    {Option, Tail1} = get_option(OptSpecList, OptStr, ShortName, ?OPT_SHORT, Tail),
+    {Option, Tail1} = get_option(OptSpecList, OptStr, ?OPT_SHORT, ShortName, Tail),
     parse(OptSpecList, [Option | OptAcc], ArgAcc, ArgPos, Tail1);
 %% Process multiple short options with no argument.
 parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [[$- | ShortNameList] = OptStr | Tail]) ->
@@ -87,12 +96,21 @@ parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [[$- | ShortNameList] = OptStr | Tail
           end, OptAcc, ShortNameList),
     parse(OptSpecList, NewOptAcc, ArgAcc, ArgPos, Tail);
 %% Process non-option arguments.
-parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [Arg | Tail]) ->
+parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [OptStr | Tail]) ->
+    case split_embedded_arg(OptStr) of
+        {Name, Arg} ->
+            %% Get option that has its argument within the same string
+            %% separated by an equal ('=') character.
+            parse(OptSpecList, [get_option_embedded_arg(OptSpecList, OptStr, ?OPT_LONG, Name, Arg) | OptAcc],
+                  ArgAcc, ArgPos, Tail);
+        Arg ->
             case find_non_option_arg(OptSpecList, ArgPos) of
                 {value, OptSpec} when ?IS_OPT_SPEC(OptSpec) ->
-            parse(OptSpecList, [convert_option_arg(OptSpec, Arg) | OptAcc], ArgAcc, ArgPos + 1, Tail);
+                    parse(OptSpecList, [convert_option_arg(OptSpec, Arg) | OptAcc],
+                          ArgAcc, ArgPos + 1, Tail);
                 false ->
                     parse(OptSpecList, OptAcc, [Arg | ArgAcc], ArgPos, Tail)
+            end
     end;
 parse(OptSpecList, OptAcc, ArgAcc, _ArgPos, []) ->
     %% Once we have completed gathering the options we add the ones that were
@@ -100,28 +118,75 @@ parse(OptSpecList, OptAcc, ArgAcc, _ArgPos, []) ->
     {ok, {lists:reverse(append_default_args(OptSpecList, OptAcc)), lists:reverse(ArgAcc)}}.
 
 
--spec get_option([option_spec()], string(), string() | char(), integer(), [string()]) ->
+-spec get_option([option_spec()], string(), integer(), string() | char(), [string()]) ->
     {option(), [string()]}.
 %% @doc Retrieve the specification corresponding to an option matching a string
 %%      received on the command line.
-get_option(OptSpecList, OptStr, OptName, FieldPos, Tail) ->
+get_option(OptSpecList, OptStr, FieldPos, OptName, Tail) ->
     case lists:keysearch(OptName, FieldPos, OptSpecList) of
         {value, {Name, _Short, _Long, ArgSpec, _Help} = OptSpec} ->
             case ArgSpec of
                 undefined ->
                     {Name, Tail};
                 _ ->
+                    ArgSpecType = arg_spec_type(ArgSpec),
                     case Tail of
                         [Arg | Tail1] ->
-                            {convert_option_arg(OptSpec, Arg), Tail1};
+                            case (ArgSpecType =:= boolean) andalso not is_boolean_arg(Arg) of
+                                %% Special case for booleans: when the next string
+                                %% is an option we assume the value is 'true'.
+                                true ->
+                                    {{Name, true}, Tail};
+                                _ ->
+                                    {convert_option_arg(OptSpec, Arg), Tail1}
+                            end;
                         [] ->
+                            case ArgSpecType of
+                                boolean ->
+                                    {{Name, true}, Tail};
+                                _ ->
                                     throw({error, {missing_option_arg, Name}})
                             end
+                    end
             end;
         false ->
             throw({error, {invalid_option, OptStr}})
     end.
 
+
+-spec get_option_embedded_arg([option_spec()], string(), integer(), string(),
+                              string()) ->  option().
+%% @doc Retrieve the specification corresponding to an option matching a string
+%%      received on the command line that had its argument assigned within the
+%%      same string (e.g. "verbose=true").
+get_option_embedded_arg(OptSpecList, OptStr, FieldPos, OptName, Arg) ->
+    case lists:keysearch(OptName, FieldPos, OptSpecList) of
+        {value, {_Name, _Short, _Long, ArgSpec, _Help} = OptSpec} ->
+            case ArgSpec of
+                undefined ->
+                    throw({error, {invalid_option_arg, OptStr}});
+                _ ->
+                    convert_option_arg(OptSpec, Arg)
+            end;
+        false ->
+            throw({error, {invalid_option, OptStr}})
+    end.
+
+
+-spec split_embedded_arg(string()) -> {Name :: string(), Arg :: string()} | string().
+%% @doc Split an option string that may contain and option with its argument
+%%      separated by an equal ('=') character (e.g. "port=1000").
+split_embedded_arg(OptStr) ->
+    split_embedded_arg(OptStr, OptStr, []).
+
+split_embedded_arg(_OptStr, [$= | Tail], Acc) ->
+    {lists:reverse(Acc), Tail};
+split_embedded_arg(OptStr, [Char | Tail], Acc) ->
+    split_embedded_arg(OptStr, Tail, [Char | Acc]);
+split_embedded_arg(OptStr, [], _Acc) ->
+    OptStr.
+
+
 -spec get_option_no_arg([option_spec()], string(), string() | char(), integer()) -> option().
 %% @doc Retrieve the specification corresponding to an option that has no
 %%      argument and matches a string received on the command line.
@@ -129,12 +194,20 @@ get_option_no_arg(OptSpecList, OptStr, OptName, FieldPos) ->
     case lists:keysearch(OptName, FieldPos, OptSpecList) of
         {value, {Name, _Short, _Long, undefined, _Help}} ->
             Name;
-        {value, {Name, _Short, _Long, _ArgSpec, _Help}} ->
+        {value, {Name, _Short, _Long, ArgSpec, _Help}} ->
-            throw({error, {missing_option_arg, Name}});
+            case arg_spec_type(ArgSpec) of
+                %% Special case for booleans: if there is no argument we assume
+                %% the value is 'true'.
+                boolean ->
+                    {Name, true};
+                _ ->
+                    throw({error, {missing_option_arg, Name}})
+            end;
         false ->
             throw({error, {invalid_option, OptStr}})
     end.
 
+
 -spec find_non_option_arg([option_spec()], integer()) -> {value, option_spec()} | false.
 %% @doc Find the option for the discrete argument in position specified in the
 %%      Pos argument.
@@ -165,23 +238,30 @@ append_default_args([], OptAcc) ->
     OptAcc.
 
 
+%% -spec is_option(string()) -> boolean().
+%% is_option([Char | _Tail] = OptStr) ->
+%%     (Char =:= $-) orelse lists:member($=, OptStr).
+    
+
 -spec convert_option_arg(option_spec(), string()) -> [option()].
 %% @doc Convert the argument passed in the command line to the data type
-%%      indicated byt the argument specification.
+%%      indicated by the argument specification.
 convert_option_arg({Name, _Short, _Long, ArgSpec, _Help}, Arg) ->
     try
-        Converted = case ArgSpec of
+        {Name, to_type(arg_spec_type(ArgSpec), Arg)}
-                        {Type, _DefaultArg} ->
-                            to_type(Type, Arg);
-                        Type when is_atom(Type) ->
-                            to_type(Type, Arg)
-                    end,
-        {Name, Converted}
     catch
         error:_ ->
             throw({error, {invalid_option_arg, {Name, Arg}}})
     end.
 
+
+-spec arg_spec_type(arg_spec()) -> arg_type() | undefined.
+arg_spec_type({Type, _DefaultArg}) ->
+    Type;
+arg_spec_type(Type) when is_atom(Type) ->
+    Type.
+
+
 -spec to_type(atom(), string()) -> arg_value().
 to_type(binary, Arg) ->
     list_to_binary(Arg);
@@ -192,12 +272,18 @@ to_type(integer, Arg) ->
 to_type(float, Arg) ->
     list_to_float(Arg);
 to_type(boolean, Arg) ->
+    is_boolean_arg(Arg);
+to_type(_Type, Arg) ->
+    Arg.
+
+
+-spec is_boolean_arg(string()) -> boolean().
+is_boolean_arg(Arg) ->
     LowerArg = string:to_lower(Arg),
     (LowerArg =:= "true") orelse (LowerArg =:= "t") orelse
     (LowerArg =:= "yes") orelse (LowerArg =:= "y") orelse
-    (LowerArg =:= "on") orelse (LowerArg =:= "enabled");
+    (LowerArg =:= "on") orelse (LowerArg =:= "enabled") orelse
-to_type(_Type, Arg) ->
+    (LowerArg =:= "1").
-    Arg.
     
 
 -spec usage([option_spec()], string()) -> ok.

src/rebar_config.erl

@@ -81,12 +81,7 @@ get_global(Key, Default) ->
     end.
 
 is_verbose() ->
-    case get_global(verbose, "0") of
+    get_global(verbose, false).
-        "1" ->
-            true;
-        _ ->
-            false
-    end.
 
 
 %% ===================================================================

src/rebar_core.erl

@@ -49,17 +49,20 @@ run(Args) ->
     %% Pre-load the rebar app so that we get default configuration
     ok = application:load(rebar),
 
+    OptSpecList = option_spec_list(),
     %% Parse getopt options
-    case getopt:parse(option_spec_list(), Args) of
+    case getopt:parse(OptSpecList, Args) of
+        {ok, {_Options, []}} ->
+            %% no command to run specified
+            getopt:usage(OptSpecList, "rebar");
         {ok, {Options, NonOptArgs}} ->
             case proplists:get_bool(help, Options) of
                 true ->
-                    %% display usage info
+                    %% display help
-                    getopt:usage(option_spec_list(), "rebar");
+                    getopt:usage(OptSpecList, "rebar");
                 false ->
-                    %% Set global variables based on getopt options
+                    %% set global variables based on getopt options
                     set_global_flag(Options, verbose),
-                    set_global_flag(Options, quiet),
                     set_global_flag(Options, force),
 
                     %% run rebar with supplied options
@@ -67,20 +70,16 @@ run(Args) ->
             end;
         {error, {Reason, Data}} ->
             ?ERROR("Error: ~s ~p~n~n", [Reason, Data]),
-            getopt:usage(option_spec_list(), "rebar")
+            getopt:usage(OptSpecList, "rebar")
     end.
 
-run2(Args) ->
+run2(Commands) ->
     %% Make sure crypto is running
     crypto:start(),
 
     %% Initialize logging system
     rebar_log:init(),
 
-    %% Filter all the flags (i.e. string of form key=value) from the
-    %% command line arguments. What's left will be the commands to run.
-    Commands = filter_flags(Args, []),
-
     %% Convert command strings to atoms
     CommandAtoms = [list_to_atom(C) || C <- Commands],
 
@@ -96,12 +95,7 @@ run2(Args) ->
 %% set global flag based on getopt option boolean value
 %%
 set_global_flag(Options, Flag) ->
-    Value = case proplists:get_bool(Flag, Options) of
+    Value = proplists:get_bool(Flag, Options),
-                true ->
-                    "1";
-                false ->
-                    "0"
-            end,
     rebar_config:set_global(Flag, Value).
 
 %%
@@ -111,31 +105,10 @@ option_spec_list() ->
     [
      %% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
      {help,    $h, "help",    undefined, "Show the program options"},
-     {verbose, $v, "verbose", undefined, "Be verbose about what gets done"},
+     {verbose, $v, "verbose", {boolean, false}, "Be verbose about what gets done"},
-     {quiet,   $q, "quiet",   undefined, "Be quiet about what gets done"},
+     {force,   $f, "force",   {boolean, false}, "Force"}
-     {force,   $f, "force",   undefined, "Force"}
     ].
 
-%%
-%% Seperate all commands (single-words) from flags (key=value) and store
-%% values into the rebar_config global storage.
-%%
-filter_flags([], Commands) ->
-    lists:reverse(Commands);
-filter_flags([Item | Rest], Commands) ->
-    case string:tokens(Item, "=") of
-        [Command] ->
-            filter_flags(Rest, [Command | Commands]);
-        [KeyStr, Value] ->
-            Key = list_to_atom(KeyStr),
-            rebar_config:set_global(Key, Value),
-            filter_flags(Rest, Commands);
-        Other ->
-            ?CONSOLE("Ignoring command line argument: ~p\n", [Other]),
-            filter_flags(Rest, Commands)
-    end.
-
-
 process_dir(Dir, ParentConfig, Commands) ->
     ok = file:set_cwd(Dir),
     Config = rebar_config:new(ParentConfig),

src/rebar_ct.erl

@@ -71,8 +71,8 @@ run_test_if_present(TestDir, Config, File) ->
 run_test(TestDir, Config, _File) ->
     {Cmd, RawLog} = make_cmd(TestDir, Config),
     clear_log(RawLog),
-    case rebar_config:get_global(verbose, "0") of
+    case rebar_config:is_verbose() of
-	"0" ->
+	true ->
 	    Output = " >> " ++ RawLog ++ " 2>&1";
 	_ ->
 	    Output = " 2>&1 | tee -a " ++ RawLog
@@ -123,8 +123,8 @@ check_log(RawLog) ->
 %% Show the log if it hasn't already been shown because verbose was on
 show_log(RawLog) ->
     ?CONSOLE("Showing log\n", []),
-    case rebar_config:get_global(verbose, "0") of
+    case rebar_config:is_verbose() of
-	"0" ->
+	true ->
 	    {ok, Contents} = file:read_file(RawLog),
 	    ?CONSOLE("~s", [Contents]);
 	_ ->

src/rebar_log.erl

@@ -33,8 +33,8 @@
 %% ===================================================================
 
 init() ->
-    case rebar_config:get_global(verbose, "0") of
+    case rebar_config:is_verbose() of
-        "1" ->
+        true ->
             set_level(debug);
         _ ->
             set_level(error)

src/rebar_otp_app.erl

@@ -63,11 +63,11 @@ install(Config, File) ->
         true ->
             %% Already exists -- check for force=1 global flag and only
             %% continue if it's set
-            case rebar_config:get_global(force, "0") of
+            case rebar_config:get_global(force, false) of
-                "0" ->
+                false ->
                     ?ERROR("~s already exists. Installation failed.\n", [AppId]),
                     ?FAIL;
-                "1" ->
+                true ->
                     ?WARN("~s already exists, but forcibly overwriting.\n", [AppId])
             end;
         false ->

src/rebar_reltool.erl

@@ -177,8 +177,8 @@ mk_target_dir(TargetDir) ->
             ok;
         {error, eexist} ->
             %% Output directory already exists; if force=1, wipe it out
-            case rebar_config:get_global(force, "0") of
+            case rebar_config:get_global(force, false) of
-                "1" ->
+                true ->
                     rebar_file_utils:rm_rf(TargetDir),
                     ok = file:make_dir(TargetDir);
                 _ ->