From 7e29b8254f08af820b2f0c3770836638ffe517ab Mon Sep 17 00:00:00 2001 From: Nguyễn Thái Ngọc Duy Date: Sat, 21 Apr 2012 11:44:32 +0700 Subject: Add column layout skeleton and git-column MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A column option string consists of many token separated by either a space or a comma. A token belongs to one of three groups: - enabling: always, never and auto - layout mode: currently plain (which does not layout at all) - other future tuning flags git-column can be used to pipe output to from a command that wants column layout, but not to mess with its own output code. Simpler output code can be changed to use column layout code directly. Thanks-to: Ramsay Jones Signed-off-by: Nguyễn Thái Ngọc Duy Signed-off-by: Junio C Hamano --- column.c | 169 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 column.c (limited to 'column.c') diff --git a/column.c b/column.c new file mode 100644 index 0000000000..3349f5855b --- /dev/null +++ b/column.c @@ -0,0 +1,169 @@ +#include "cache.h" +#include "column.h" +#include "string-list.h" +#include "parse-options.h" + +/* Display without layout when not enabled */ +static void display_plain(const struct string_list *list, + const char *indent, const char *nl) +{ + int i; + + for (i = 0; i < list->nr; i++) + printf("%s%s%s", indent, list->items[i].string, nl); +} + +void print_columns(const struct string_list *list, unsigned int colopts, + const struct column_options *opts) +{ + struct column_options nopts; + + if (!list->nr) + return; + assert((colopts & COL_ENABLE_MASK) != COL_AUTO); + + memset(&nopts, 0, sizeof(nopts)); + nopts.indent = opts && opts->indent ? opts->indent : ""; + nopts.nl = opts && opts->nl ? opts->nl : "\n"; + nopts.padding = opts ? opts->padding : 1; + nopts.width = opts && opts->width ? opts->width : term_columns() - 1; + if (!column_active(colopts)) { + display_plain(list, "", "\n"); + return; + } + switch (COL_LAYOUT(colopts)) { + case COL_PLAIN: + display_plain(list, nopts.indent, nopts.nl); + break; + default: + die("BUG: invalid layout mode %d", COL_LAYOUT(colopts)); + } +} + +int finalize_colopts(unsigned int *colopts, int stdout_is_tty) +{ + if ((*colopts & COL_ENABLE_MASK) == COL_AUTO) { + if (stdout_is_tty < 0) + stdout_is_tty = isatty(1); + *colopts &= ~COL_ENABLE_MASK; + if (stdout_is_tty) + *colopts |= COL_ENABLED; + } + return 0; +} + +struct colopt { + const char *name; + unsigned int value; + unsigned int mask; +}; + +#define LAYOUT_SET 1 +#define ENABLE_SET 2 + +static int parse_option(const char *arg, int len, unsigned int *colopts, + int *group_set) +{ + struct colopt opts[] = { + { "always", COL_ENABLED, COL_ENABLE_MASK }, + { "never", COL_DISABLED, COL_ENABLE_MASK }, + { "auto", COL_AUTO, COL_ENABLE_MASK }, + { "plain", COL_PLAIN, COL_LAYOUT_MASK }, + }; + int i; + + for (i = 0; i < ARRAY_SIZE(opts); i++) { + int arg_len = len, name_len; + const char *arg_str = arg; + + name_len = strlen(opts[i].name); + if (arg_len != name_len || + strncmp(arg_str, opts[i].name, name_len)) + continue; + + switch (opts[i].mask) { + case COL_ENABLE_MASK: + *group_set |= ENABLE_SET; + break; + case COL_LAYOUT_MASK: + *group_set |= LAYOUT_SET; + break; + } + + if (opts[i].mask) + *colopts = (*colopts & ~opts[i].mask) | opts[i].value; + return 0; + } + + return error("unsupported option '%s'", arg); +} + +static int parse_config(unsigned int *colopts, const char *value) +{ + const char *sep = " ,"; + int group_set = 0; + + while (*value) { + int len = strcspn(value, sep); + if (len) { + if (parse_option(value, len, colopts, &group_set)) + return -1; + + value += len; + } + value += strspn(value, sep); + } + /* + * Setting layout implies "always" if neither always, never + * nor auto is specified. + * + * Current value in COL_ENABLE_MASK is disregarded. This means if + * you set column.ui = auto and pass --column=row, then "auto" + * will become "always". + */ + if ((group_set & LAYOUT_SET) && !(group_set & ENABLE_SET)) + *colopts = (*colopts & ~COL_ENABLE_MASK) | COL_ENABLED; + return 0; +} + +static int column_config(const char *var, const char *value, + const char *key, unsigned int *colopts) +{ + if (!value) + return config_error_nonbool(var); + if (parse_config(colopts, value)) + return error("invalid column.%s mode %s", key, value); + return 0; +} + +int git_column_config(const char *var, const char *value, + const char *command, unsigned int *colopts) +{ + const char *it = skip_prefix(var, "column."); + if (!it) + return 0; + + if (!strcmp(it, "ui")) + return column_config(var, value, "ui", colopts); + + if (command && !strcmp(it, command)) + return column_config(var, value, it, colopts); + + return 0; +} + +int parseopt_column_callback(const struct option *opt, + const char *arg, int unset) +{ + unsigned int *colopts = opt->value; + *colopts |= COL_PARSEOPT; + *colopts &= ~COL_ENABLE_MASK; + if (unset) /* --no-column == never */ + return 0; + /* --column == always unless "arg" states otherwise */ + *colopts |= COL_ENABLED; + if (arg) + return parse_config(colopts, arg); + + return 0; +} -- cgit v1.3 From 077539d734cdc4b0a3d2ea87fc487fa5c21d0311 Mon Sep 17 00:00:00 2001 From: Nguyễn Thái Ngọc Duy Date: Fri, 13 Apr 2012 17:54:35 +0700 Subject: column: add columnar layout MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit COL_COLUMN and COL_ROW fill column by column (or row by row respectively), given the terminal width and how many space between columns. All cells have equal width. Strings are supposed to be in UTF-8. Valid ANSI escape strings are OK. Signed-off-by: Nguyễn Thái Ngọc Duy Signed-off-by: Junio C Hamano --- Documentation/config.txt | 4 ++ column.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++ column.h | 2 + t/t9002-column.sh | 86 +++++++++++++++++++++++++++++++++++ 4 files changed, 206 insertions(+) (limited to 'column.c') diff --git a/Documentation/config.txt b/Documentation/config.txt index 9aabef124c..ab6ae3da72 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -848,6 +848,10 @@ column.ui:: never show in columns `auto`;; show in columns if the output is to the terminal +`column`;; + fill columns before rows (default) +`row`;; + fill rows before columns `plain`;; show in one column -- diff --git a/column.c b/column.c index 3349f5855b..05fa3e361c 100644 --- a/column.c +++ b/column.c @@ -2,6 +2,59 @@ #include "column.h" #include "string-list.h" #include "parse-options.h" +#include "utf8.h" + +#define XY2LINEAR(d, x, y) (COL_LAYOUT((d)->colopts) == COL_COLUMN ? \ + (x) * (d)->rows + (y) : \ + (y) * (d)->cols + (x)) + +struct column_data { + const struct string_list *list; + unsigned int colopts; + struct column_options opts; + + int rows, cols; + int *len; /* cell length */ +}; + +/* return length of 's' in letters, ANSI escapes stripped */ +static int item_length(unsigned int colopts, const char *s) +{ + int len, i = 0; + struct strbuf str = STRBUF_INIT; + + strbuf_addstr(&str, s); + while ((s = strstr(str.buf + i, "\033[")) != NULL) { + int len = strspn(s + 2, "0123456789;"); + i = s - str.buf; + strbuf_remove(&str, i, len + 3); /* \033[ */ + } + len = utf8_strwidth(str.buf); + strbuf_release(&str); + return len; +} + +/* + * Calculate cell width, rows and cols for a table of equal cells, given + * table width and how many spaces between cells. + */ +static void layout(struct column_data *data, int *width) +{ + int i; + + *width = 0; + for (i = 0; i < data->list->nr; i++) + if (*width < data->len[i]) + *width = data->len[i]; + + *width += data->opts.padding; + + data->cols = (data->opts.width - strlen(data->opts.indent)) / *width; + if (data->cols == 0) + data->cols = 1; + + data->rows = DIV_ROUND_UP(data->list->nr, data->cols); +} /* Display without layout when not enabled */ static void display_plain(const struct string_list *list, @@ -13,6 +66,61 @@ static void display_plain(const struct string_list *list, printf("%s%s%s", indent, list->items[i].string, nl); } +/* Print a cell to stdout with all necessary leading/traling space */ +static int display_cell(struct column_data *data, int initial_width, + const char *empty_cell, int x, int y) +{ + int i, len, newline; + + i = XY2LINEAR(data, x, y); + if (i >= data->list->nr) + return -1; + len = data->len[i]; + if (COL_LAYOUT(data->colopts) == COL_COLUMN) + newline = i + data->rows >= data->list->nr; + else + newline = x == data->cols - 1 || i == data->list->nr - 1; + + printf("%s%s%s", + x == 0 ? data->opts.indent : "", + data->list->items[i].string, + newline ? data->opts.nl : empty_cell + len); + return 0; +} + +/* Display COL_COLUMN or COL_ROW */ +static void display_table(const struct string_list *list, + unsigned int colopts, + const struct column_options *opts) +{ + struct column_data data; + int x, y, i, initial_width; + char *empty_cell; + + memset(&data, 0, sizeof(data)); + data.list = list; + data.colopts = colopts; + data.opts = *opts; + + data.len = xmalloc(sizeof(*data.len) * list->nr); + for (i = 0; i < list->nr; i++) + data.len[i] = item_length(colopts, list->items[i].string); + + layout(&data, &initial_width); + + empty_cell = xmalloc(initial_width + 1); + memset(empty_cell, ' ', initial_width); + empty_cell[initial_width] = '\0'; + for (y = 0; y < data.rows; y++) { + for (x = 0; x < data.cols; x++) + if (display_cell(&data, initial_width, empty_cell, x, y)) + break; + } + + free(data.len); + free(empty_cell); +} + void print_columns(const struct string_list *list, unsigned int colopts, const struct column_options *opts) { @@ -35,6 +143,10 @@ void print_columns(const struct string_list *list, unsigned int colopts, case COL_PLAIN: display_plain(list, nopts.indent, nopts.nl); break; + case COL_ROW: + case COL_COLUMN: + display_table(list, colopts, &nopts); + break; default: die("BUG: invalid layout mode %d", COL_LAYOUT(colopts)); } @@ -69,6 +181,8 @@ static int parse_option(const char *arg, int len, unsigned int *colopts, { "never", COL_DISABLED, COL_ENABLE_MASK }, { "auto", COL_AUTO, COL_ENABLE_MASK }, { "plain", COL_PLAIN, COL_LAYOUT_MASK }, + { "column", COL_COLUMN, COL_LAYOUT_MASK }, + { "row", COL_ROW, COL_LAYOUT_MASK }, }; int i; diff --git a/column.h b/column.h index b8719b3976..ec7e1d26e5 100644 --- a/column.h +++ b/column.h @@ -10,6 +10,8 @@ #define COL_AUTO 0x0020 #define COL_LAYOUT(c) ((c) & COL_LAYOUT_MASK) +#define COL_COLUMN 0 /* Fill columns before rows */ +#define COL_ROW 1 /* Fill rows before columns */ #define COL_PLAIN 15 /* one column */ #define explicitly_enable_column(c) \ diff --git a/t/t9002-column.sh b/t/t9002-column.sh index a7f3cd9285..ec288aeb95 100755 --- a/t/t9002-column.sh +++ b/t/t9002-column.sh @@ -42,4 +42,90 @@ EOF test_cmp expected actual ' +test_expect_success '80 columns' ' + cat >expected <<\EOF && +one two three four five six seven eight nine ten eleven +EOF + COLUMNS=80 git column --mode=column actual && + test_cmp expected actual +' + +test_expect_success 'COLUMNS = 1' ' + cat >expected <<\EOF && +one +two +three +four +five +six +seven +eight +nine +ten +eleven +EOF + COLUMNS=1 git column --mode=column actual && + test_cmp expected actual +' + +test_expect_success 'width = 1' ' + git column --mode=column --width=1 actual && + test_cmp expected actual +' + +COLUMNS=20 +export COLUMNS + +test_expect_success '20 columns' ' + cat >expected <<\EOF && +one seven +two eight +three nine +four ten +five eleven +six +EOF + git column --mode=column actual && + test_cmp expected actual +' + +test_expect_success '20 columns, padding 2' ' + cat >expected <<\EOF && +one seven +two eight +three nine +four ten +five eleven +six +EOF + git column --mode=column --padding 2 actual && + test_cmp expected actual +' + +test_expect_success '20 columns, indented' ' + cat >expected <<\EOF && + one seven + two eight + three nine + four ten + five eleven + six +EOF + git column --mode=column --indent=" " actual && + test_cmp expected actual +' + +test_expect_success '20 columns, row first' ' + cat >expected <<\EOF && +one two +three four +five six +seven eight +nine ten +eleven +EOF + git column --mode=row actual && + test_cmp expected actual +' + test_done -- cgit v1.3 From 3f8eccbe166ecff79a986b7ce87df4963cc873b2 Mon Sep 17 00:00:00 2001 From: Nguyễn Thái Ngọc Duy Date: Fri, 13 Apr 2012 17:54:36 +0700 Subject: column: add dense layout support MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Normally all cells (and in turn columns) share the same width. This layout mode can waste space because one long item can stretch our all columns. With COL_DENSE enabled, column width is calculated indepdendently. All columns are shrunk to minimum, then it attempts to push cells of the last row over to the next column with hope that everything still fits even there's one row less. The process is repeated until the new layout cannot fit in given width any more, or there's only one row left (perfect!). Apparently, this mode consumes more cpu than the old one, but it makes better use of terminal space. For layouting one or two screens, cpu usage should not be detectable. This patch introduces option handling code besides layout modes and enable/disable to expose this feature as "dense". The feature can be turned off by specifying "nodense". Thanks-to: Ramsay Jones Signed-off-by: Nguyễn Thái Ngọc Duy Signed-off-by: Junio C Hamano --- Documentation/config.txt | 4 +++ column.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++- column.h | 2 ++ t/t9002-column.sh | 48 +++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) (limited to 'column.c') diff --git a/Documentation/config.txt b/Documentation/config.txt index ab6ae3da72..01905a74ce 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -854,6 +854,10 @@ column.ui:: fill rows before columns `plain`;; show in one column +`dense`;; + make unequal size columns to utilize more space +`nodense`;; + make equal size columns -- + This option defaults to 'never'. diff --git a/column.c b/column.c index 05fa3e361c..d6c115c1bf 100644 --- a/column.c +++ b/column.c @@ -15,6 +15,7 @@ struct column_data { int rows, cols; int *len; /* cell length */ + int *width; /* index to the longest row in column */ }; /* return length of 's' in letters, ANSI escapes stripped */ @@ -56,6 +57,57 @@ static void layout(struct column_data *data, int *width) data->rows = DIV_ROUND_UP(data->list->nr, data->cols); } +static void compute_column_width(struct column_data *data) +{ + int i, x, y; + for (x = 0; x < data->cols; x++) { + data->width[x] = XY2LINEAR(data, x, 0); + for (y = 0; y < data->rows; y++) { + i = XY2LINEAR(data, x, y); + if (i < data->list->nr && + data->len[data->width[x]] < data->len[i]) + data->width[x] = i; + } + } +} + +/* + * Shrink all columns by shortening them one row each time (and adding + * more columns along the way). Hopefully the longest cell will be + * moved to the next column, column is shrunk so we have more space + * for new columns. The process ends when the whole thing no longer + * fits in data->total_width. + */ +static void shrink_columns(struct column_data *data) +{ + data->width = xrealloc(data->width, + sizeof(*data->width) * data->cols); + while (data->rows > 1) { + int x, total_width, cols, rows; + rows = data->rows; + cols = data->cols; + + data->rows--; + data->cols = DIV_ROUND_UP(data->list->nr, data->rows); + if (data->cols != cols) + data->width = xrealloc(data->width, + sizeof(*data->width) * data->cols); + compute_column_width(data); + + total_width = strlen(data->opts.indent); + for (x = 0; x < data->cols; x++) { + total_width += data->len[data->width[x]]; + total_width += data->opts.padding; + } + if (total_width > data->opts.width) { + data->rows = rows; + data->cols = cols; + break; + } + } + compute_column_width(data); +} + /* Display without layout when not enabled */ static void display_plain(const struct string_list *list, const char *indent, const char *nl) @@ -75,7 +127,18 @@ static int display_cell(struct column_data *data, int initial_width, i = XY2LINEAR(data, x, y); if (i >= data->list->nr) return -1; + len = data->len[i]; + if (data->width && data->len[data->width[x]] < initial_width) { + /* + * empty_cell has initial_width chars, if real column + * is narrower, increase len a bit so we fill less + * space. + */ + len += initial_width - data->len[data->width[x]]; + len -= data->opts.padding; + } + if (COL_LAYOUT(data->colopts) == COL_COLUMN) newline = i + data->rows >= data->list->nr; else @@ -108,6 +171,9 @@ static void display_table(const struct string_list *list, layout(&data, &initial_width); + if (colopts & COL_DENSE) + shrink_columns(&data); + empty_cell = xmalloc(initial_width + 1); memset(empty_cell, ' ', initial_width); empty_cell[initial_width] = '\0'; @@ -118,6 +184,7 @@ static void display_table(const struct string_list *list, } free(data.len); + free(data.width); free(empty_cell); } @@ -183,13 +250,22 @@ static int parse_option(const char *arg, int len, unsigned int *colopts, { "plain", COL_PLAIN, COL_LAYOUT_MASK }, { "column", COL_COLUMN, COL_LAYOUT_MASK }, { "row", COL_ROW, COL_LAYOUT_MASK }, + { "dense", COL_DENSE, 0 }, }; int i; for (i = 0; i < ARRAY_SIZE(opts); i++) { - int arg_len = len, name_len; + int set = 1, arg_len = len, name_len; const char *arg_str = arg; + if (!opts[i].mask) { + if (arg_len > 2 && !strncmp(arg_str, "no", 2)) { + arg_str += 2; + arg_len -= 2; + set = 0; + } + } + name_len = strlen(opts[i].name); if (arg_len != name_len || strncmp(arg_str, opts[i].name, name_len)) @@ -206,6 +282,12 @@ static int parse_option(const char *arg, int len, unsigned int *colopts, if (opts[i].mask) *colopts = (*colopts & ~opts[i].mask) | opts[i].value; + else { + if (set) + *colopts |= opts[i].value; + else + *colopts &= ~opts[i].value; + } return 0; } diff --git a/column.h b/column.h index ec7e1d26e5..4f178d84a8 100644 --- a/column.h +++ b/column.h @@ -4,6 +4,8 @@ #define COL_LAYOUT_MASK 0x000F #define COL_ENABLE_MASK 0x0030 /* always, never or auto */ #define COL_PARSEOPT 0x0040 /* --column is given from cmdline */ +#define COL_DENSE 0x0080 /* Shrink columns when possible, + making space for more columns */ #define COL_DISABLED 0x0000 /* must be zero */ #define COL_ENABLED 0x0010 diff --git a/t/t9002-column.sh b/t/t9002-column.sh index fb71949ebd..89983527b6 100755 --- a/t/t9002-column.sh +++ b/t/t9002-column.sh @@ -90,6 +90,30 @@ EOF test_cmp expected actual ' +test_expect_success '20 columns, nodense' ' + cat >expected <<\EOF && +one seven +two eight +three nine +four ten +five eleven +six +EOF + git column --mode=column,nodense < lista > actual && + test_cmp expected actual +' + +test_expect_success '20 columns, dense' ' + cat >expected <<\EOF && +one five nine +two six ten +three seven eleven +four eight +EOF + git column --mode=column,dense < lista > actual && + test_cmp expected actual +' + test_expect_success '20 columns, padding 2' ' cat >expected <<\EOF && one seven @@ -129,4 +153,28 @@ EOF test_cmp expected actual ' +test_expect_success '20 columns, row first, nodense' ' + cat >expected <<\EOF && +one two +three four +five six +seven eight +nine ten +eleven +EOF + git column --mode=row,nodense actual && + test_cmp expected actual +' + +test_expect_success '20 columns, row first, dense' ' + cat >expected <<\EOF && +one two three +four five six +seven eight nine +ten eleven +EOF + git column --mode=row,dense actual && + test_cmp expected actual +' + test_done -- cgit v1.3 From b27004eb32139977f8fa5c01eb235535661f9201 Mon Sep 17 00:00:00 2001 From: Nguyễn Thái Ngọc Duy Date: Fri, 13 Apr 2012 17:54:40 +0700 Subject: column: support piping stdout to external git-column process MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit For too complicated output handling, it'd be easier to just spawn git-column and redirect stdout to it. This patch provides helpers to do that. Signed-off-by: Nguyễn Thái Ngọc Duy Signed-off-by: Junio C Hamano --- column.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ column.h | 3 +++ 2 files changed, 72 insertions(+) (limited to 'column.c') diff --git a/column.c b/column.c index d6c115c1bf..9367ba5db5 100644 --- a/column.c +++ b/column.c @@ -2,6 +2,7 @@ #include "column.h" #include "string-list.h" #include "parse-options.h" +#include "run-command.h" #include "utf8.h" #define XY2LINEAR(d, x, y) (COL_LAYOUT((d)->colopts) == COL_COLUMN ? \ @@ -363,3 +364,71 @@ int parseopt_column_callback(const struct option *opt, return 0; } + +static int fd_out = -1; +static struct child_process column_process; + +int run_column_filter(int colopts, const struct column_options *opts) +{ + const char *av[10]; + int ret, ac = 0; + struct strbuf sb_colopt = STRBUF_INIT; + struct strbuf sb_width = STRBUF_INIT; + struct strbuf sb_padding = STRBUF_INIT; + + if (fd_out != -1) + return -1; + + av[ac++] = "column"; + strbuf_addf(&sb_colopt, "--raw-mode=%d", colopts); + av[ac++] = sb_colopt.buf; + if (opts && opts->width) { + strbuf_addf(&sb_width, "--width=%d", opts->width); + av[ac++] = sb_width.buf; + } + if (opts && opts->indent) { + av[ac++] = "--indent"; + av[ac++] = opts->indent; + } + if (opts && opts->padding) { + strbuf_addf(&sb_padding, "--padding=%d", opts->padding); + av[ac++] = sb_padding.buf; + } + av[ac] = NULL; + + fflush(stdout); + memset(&column_process, 0, sizeof(column_process)); + column_process.in = -1; + column_process.out = dup(1); + column_process.git_cmd = 1; + column_process.argv = av; + + ret = start_command(&column_process); + + strbuf_release(&sb_colopt); + strbuf_release(&sb_width); + strbuf_release(&sb_padding); + + if (ret) + return -2; + + fd_out = dup(1); + close(1); + dup2(column_process.in, 1); + close(column_process.in); + return 0; +} + +int stop_column_filter(void) +{ + if (fd_out == -1) + return -1; + + fflush(stdout); + close(1); + finish_command(&column_process); + dup2(fd_out, 1); + close(fd_out); + fd_out = -1; + return 0; +} diff --git a/column.h b/column.h index 4f178d84a8..0a61917fa7 100644 --- a/column.h +++ b/column.h @@ -39,4 +39,7 @@ static inline int column_active(unsigned int colopts) extern void print_columns(const struct string_list *list, unsigned int colopts, const struct column_options *opts); +extern int run_column_filter(int colopts, const struct column_options *); +extern int stop_column_filter(void); + #endif -- cgit v1.3