updated Changelog

CHANGELOG.md

@@ -0,0 +1,179 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org).
+
+## [v1.0.10](https://github.com/TLINDEN/tablizer/tree/v1.0.10) - 2022-10-15
+
+### Added
+
+- Added various sort modes: sort by time, by duration, numerical (-a -t -i)
+
+- Added possibility to modify sort order to descending (-D)
+
+- Added support  to specify a regexp in column  selector -c, which can
+  also be mixed with numerical column spec
+  
+- More unit tests
+
+### Fixed
+
+- Column specification  allowed to specify duplicate  columns like `-c
+  1,2,1,2` unchecked. Now this list will be deduplicated before use.
+
+
+
+## [v1.0.9](https://github.com/TLINDEN/tablizer/tree/v1.0.9) - 2022-10-14
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.8...v1.0.9)
+
+### Added
+
+- Added Changelog, Contribution guidelines and no COC.
+
+### Changed
+
+- some minor changes to satisfy linter.
+
+
+
+## [v1.0.8](https://github.com/TLINDEN/tablizer/tree/v1.0.8) - 2022-10-13
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.7...v1.0.8)
+
+### Added
+
+- Added sort support with the new parameter -k (like sort(1).
+
+
+
+## [v1.0.7](https://github.com/TLINDEN/tablizer/tree/v1.0.7) - 2022-10-11
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.6...v1.0.7)
+
+### Added
+
+- Added pattern highlighting support.
+
+- Added more unit tests.
+
+### Fixed
+
+- Fixed extended more output in combination with -c.
+
+- Fixed issue #4, the version string was missing.
+
+
+
+## [v1.0.6](https://github.com/TLINDEN/tablizer/tree/v1.0.6) - 2022-10-05
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.5...v1.0.6)
+
+### Added
+
+- Added documentation about regexp syntax in the manpage.
+
+- Added more unit tests.
+
+### Changed
+
+- Rewrote the input parser.
+
+- Some more refactoring work has been done.
+
+
+
+## [v1.0.5](https://github.com/TLINDEN/tablizer/tree/v1.0.5) - 2022-10-05
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.4...v1.0.5)
+
+### Added
+
+- A  new option has been  added: --invert-match -v which  behaves like
+  the same option in grep(1): it inverts the pattern match.
+  
+- A few more unit tests have been added.
+
+### Fixed
+
+- Pattern  matching did  not work, because  the (new)  help subcommand
+  lead  to  cobra  taking  care  of  the  first  arg  to  the  program
+  (argv[1]).  So now  there's a  new parameter  -m which  displays the
+  manpage and no more subcommands.
+  
+
+
+## [v1.0.4](https://github.com/TLINDEN/tablizer/tree/v1.0.4) - 2022-10-04
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.3...v1.0.4)
+
+### Added
+
+- Development version of the compiled binary now uses git vars
+  in addition to program version.
+  
+- Added  an option to display  the manual page (compiled  in) as text:
+  --help, for cases where a user just installed the binary.
+  
+### Changed
+
+- Fixed go module namespace.
+
+
+
+## [v1.0.3](https://github.com/TLINDEN/tablizer/tree/v1.0.3) - 2022-10-03
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.2...v1.0.3)
+
+### Added
+
+- Added a new output mode: shell mode, which allows the user
+  to use the output in a shell eval loop to further process
+  the data.
+  
+### Changed
+
+- More refactoring work has been done.
+
+
+
+## [v1.0.2](https://github.com/TLINDEN/tablizer/tree/v1.0.2) - 2022-10-02
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.1...v1.0.2)
+
+### Added
+
+- Added some basic unit tests.
+
+### Changed
+
+- Code has been refactored to be more efficient.
+
+- Replaced table generation code with Tablewriter.
+
+
+
+
+
+## [v1.0.1](https://github.com/TLINDEN/tablizer/tree/v1.0.1) - 2022-09-30
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/v1.0.0...v1.0.1)
+
+### Added
+
+- Added a unix manual page.
+
+- Added release builder to Makefile
+
+### Changed
+
+- Various minor fixes.
+
+
+
+## [v1.0.0](https://github.com/TLINDEN/tablizer/tree/v1.0.0) - 2022-09-28
+
+[Full Changelog](https://github.com/TLINDEN/tablizer/compare/02a64a5c3fe4220df2c791ff1421d16ebd428c19...v1.0.0)
+
+Initial release.

CODE_OF_CONDUCT.md

@@ -0,0 +1,113 @@
+# No Code of Conduct
+
+*TL;DR:* This project  does **NOT** have a so called  Code of Conduct,
+nor will it ever have one.
+
+## The Rant
+
+The reasons are somewhat complicated and  I'll try my best to document
+them here.
+
+Ethical codes  or rules come  along like laws.  But how is  ethical or
+moral behavior defined? And who  defines which behavior is ethical and
+which is not? Certainly not me.
+
+Unless  you  live  in  a  dictatorship (and  more  than  half  of  the
+population of  planet earth  do as  of this  writing), laws  come into
+existence by democratic procedures. Laws  cover almost every aspect of
+live in  a society. Laws allow  and forbid behavior and  laws sanction
+infringements.
+
+A software project like  this one on the other hand  is not a society.
+There   are   not   enough   people  involved   to   form   democratic
+structures. And there will always be  a minority of users who have the
+right to commit or reject code. How could any maintainer of a software
+project dare to decree rules upon  others? Actually, am I, the current
+maintainer of this very project authorized to do so?
+
+I think the anser to this question clearly is NO.
+
+The  issue  is  being  complicated  by  the  fact,  that  open  source
+development these  days happens  on planetary  scale. And  this planet
+houses hundreds if not  thousands of different cultures, philosophies,
+ideologies and worldviews.  The answer  to many ethical questions will
+in most cases vague and nebulous.
+
+Ones joke will always be another ones insult.
+
+Then there  is the  problem of  language. I myself  am not  an english
+native, but I publish everyting using  the english language. I am able
+to communicate with  most people in the open  source community because
+of that.   But I am  certainly not  able to understand  everything and
+everyone. There  might be nuances to  a sentence I don't  sense, there
+might be  sarcastic connotations I  don't understand or  references to
+historical figures, events  or traditions I don't know  and never have
+heard of.
+
+Judging over other  peoples online behavior looks like  a titanic task
+to me. It is just not my job  to judge others, I am not legitimized or
+authorized to do so and I am not interested in this kind of business.
+
+Another huge  problem with ethical rules  is that you need  to outline
+and enforce sanctions  on those who violate the rules.  But since I am
+not an  elected authority  how would I  be able to  do this?   I don't
+know.  And  what happens if  someone complains about myself?   Shall I
+remove myself from my own project? Come on!
+
+Last but  not least there's  the law. So,  let's say someone  in india
+says  something insulting  to some  other developer  in an  issue.  Of
+course german  law does not apply  to indian people. More,  the insult
+might actually  not be an insult  in india. In the  end, nothing would
+happen.  Under  normal  circumstances, maintainers  would  delete  the
+posting, ban the user or remove push privileges etc.
+
+But then, is there a way for  the offending user to defend himself? Of
+course not, since neither indian or german law alone applies. I cannot
+go to  a german court  and sue the  guy and he  cannot do the  same in
+india. Or -  we possibly could but the judges  on both countries would
+just laugh and close the case.
+
+That  being said,  I  don't have  the  power nor  the  tools, nor  the
+authority to enforce serious sanctions  of any meaningful kind against
+others. Therefore I cannot outline any rules whatsoever.
+
+And let's not  even start talking about  there undemocratic "comitees"
+many projects  are forming to  circumvent this problem.  Some projects
+even  include  external  entities  like a  lawer  or  some  bureaucrat
+somewhere  just to  have the  ability  to complain  against a  comitee
+member. What a mess!
+
+
+
+## So, which are the ethical rules within this project then?
+
+Well, there are none.
+
+This project is  about code, not society. It doesn't  matter where you
+come from,  how you look,  how you think,  what you believe,  who your
+friends are, whay you  said or did sometime in the  past. I don't even
+care if you are a human being. You are an alien so bored that you need
+to submit code on github? Fine with me. You're a convicted criminal? I
+don't give a shit!
+
+**The only thing I am interested here is Code and only Code.**
+
+So if anyhing happens here I don't like  or I am obliged by law to act
+on,  I  will  decide  on  a  case to  case  basis  what  to  do.   And
+unfortunately,  since this  is the  nature  of a  github project,  you
+cannot complain, object or protest. I am very sorry!
+
+If you will, let's at least  outline these:
+
+- Please - just please -  behave towards others as you'd expect others
+  to behave towards yourself.
+
+- Don't judge others for any reason.
+
+- Only judge the code.
+
+But these are not rules, only a  friendly appeal to you as a developer
+and user.
+
+
+Thanks a lot!

CONTRIBUTING.md

@@ -0,0 +1,94 @@
+## Project Goals
+
+The goal of this  project is to build a small tool  which helps in day
+to day  work with tabular  output of various commandline  programs. It
+should be small,  fast and easy to understand. The  idea is to replace
+multiline  shell  pipes  using  awk,   sed  and  grep  with  just  one
+binary.
+
+There will be no GUI, no web interface, no public API of some sort, no
+builtin interpreter.
+
+The  programming  language  used  for  this  project  will  always  be
+[GOLANG](https://go.dev/)  with  the  exception of  the  documentation
+([Perl POD](https://perldoc.perl.org/perlpod)) and the Makefile.
+
+# Contributing
+
+You can contribute to this project in various ways:
+
+## Open an issue
+
+If you encounter  a problem or don't understand how  the program works
+or if you think the documentation is unclear, please don't hesitate to
+open an issue.
+
+Please add as much information about the case as possible, such as:
+
+- Your environment (operating system etc)
+- tablizer version (`tablizer --version`)
+- Input data. Please replace sensitive information with mock data!
+- Actual program output.
+- Expected program output.
+- Error message - if any.
+
+Be aware  that I  am working on  this (and some  other) project  in my
+spare  time which  is scarce.   Therefore  please don't  expect me  to
+respond to  your query within  hours or even  days. Be patient,  but I
+WILL respond.
+
+## Pull Requests
+
+Code and documentation help is  always much appreciated! Please follow
+thes guidelines to successfully contribute:
+
+-  Every  pull   request  shall  be  based   on  latest  `development`
+  branch. `main` is only used for releases.
+  
+- Execute the  unit tests before committing: `make  test`. There shall
+  be no errors.
+  
+- Strive  to be  backwards compatible  so that  users who  are already
+  using the program  don't have to change their habits  - unless it is
+  really neccessary.
+
+- Try to add a unit test for your addition.
+
+- Don't ever change existing unit tests!
+
+- Add a meaningful and comprehensive rationale about your contribution:
+  - Why do you think it might be useful for others?
+  - What did you actually change or add?
+  - Is there an open issue which  this PR fixes and if so, please link
+    to that issue.
+
+- [Re-]format your code with `gofmt -s`.
+
+- Avoid unneccesary dependencies, especially for very small functions.
+
+- **If** a  new dependency is being added, it  must be compatible with
+  our [license agreement](LICENSE).
+  
+- You  need to accept  that the  code or documentation  you contribute
+  will be redistributed under the  terms of said license agreement. If
+  your  contribution  is  considerably  large  or  if  you  contribute
+  regularly, then  feel free  to add  your name and  if you  want your
+  email    address     to    the    *AUTHORS*    section     of    the
+  [manpage](tablizer.pod).
+
+- Adhere to the above mentioned project goals.
+
+-  If  you are  unsure if  your addition or  change will  be accepted,
+  better ask before starting coding. Open an issue about your proposal
+  and let's  discuss it! That way  we avoid doing unnessesary  work on
+  both sides.
+    
+Each pull  request will be  carefully reviewed and  if it is  a useful
+addition  it  will  be  accepted. However,  please  be  prepared  that
+sometimes a  PR will be  rejected.  The reasons  may vary and  will be
+documented.   Perhaps the  above guidelines  are not  matched, or  the
+addition seems  to be not so  useful from my perspective,  maybe there
+are  too  much  changes  or  there  might  be  changes  I  don't  even
+understand.
+
+But whatever happens: your contribution is always welcome!

Makefile

@@ -36,6 +36,7 @@ all: $(tool).1 cmd/$(tool).go buildlocal
 
 cmd/%.go: %.pod
 	echo "package cmd" > cmd/$*.go
+	echo >> cmd/$*.go
 	echo "var manpage = \`" >> cmd/$*.go
 	pod2text $*.pod >> cmd/$*.go
 	echo "\`" >> cmd/$*.go

README.md

@@ -1,5 +1,6 @@
 [![Actions](https://github.com/tlinden/tablizer/actions/workflows/ci.yaml/badge.svg)](https://github.com/tlinden/tablizer/actions)
 [![License](https://img.shields.io/badge/license-GPL-blue.svg)](https://github.com/tlinden/tablizer/blob/master/LICENSE)
+[![Go Report Card](https://goreportcard.com/badge/github.com/tlinden/tablizer)](https://goreportcard.com/report/github.com/tlinden/tablizer)
 
 ## tablizer - Manipulate tabular output of other programs
 

TODO

@@ -1 +0,0 @@
-

TODO.md

@@ -0,0 +1,11 @@
+## Fixes to be implemented
+
+## Features to be implemented
+
+- add output modes yaml and csv
+
+- add --no-headers option
+
+-  add input  parsing support  for CSV  including unquoting  of stuff
+  like: `"xxx","1919 b"` etc, maybe an extra option for unquoting
+

cmd/root.go

@@ -60,15 +60,12 @@ var rootCmd = &cobra.Command{
 			return nil
 		}
 
-		err := lib.PrepareColumns()
+		err := lib.PrepareModeFlags()
 		if err != nil {
 			return err
 		}
 
-		err = lib.PrepareModeFlags()
-		if err != nil {
-			return err
-		}
+		lib.PrepareSortFlags()
 
 		return lib.ProcessFiles(args)
 	},
@@ -90,7 +87,13 @@ func init() {
 	rootCmd.PersistentFlags().BoolVarP(&ShowManual, "man", "m", false, "Display manual page")
 	rootCmd.PersistentFlags().StringVarP(&lib.Separator, "separator", "s", lib.DefaultSeparator, "Custom field separator")
 	rootCmd.PersistentFlags().StringVarP(&lib.Columns, "columns", "c", "", "Only show the speficied columns (separated by ,)")
+
+	// sort options
 	rootCmd.PersistentFlags().IntVarP(&lib.SortByColumn, "sort-by", "k", 0, "Sort by column (default: 1)")
+	rootCmd.PersistentFlags().BoolVarP(&lib.SortDescending, "sort-desc", "D", false, "Sort in descending order (default: ascending)")
+	rootCmd.PersistentFlags().BoolVarP(&lib.SortNumeric, "sort-numeric", "i", false, "sort according to string numerical value")
+	rootCmd.PersistentFlags().BoolVarP(&lib.SortTime, "sort-time", "t", false, "sort according to time string")
+	rootCmd.PersistentFlags().BoolVarP(&lib.SortAge, "sort-age", "a", false, "sort according to age (duration) string")
 
 	// output flags, only 1 allowed, hidden, since just short cuts
 	rootCmd.PersistentFlags().BoolVarP(&lib.OutflagExtended, "extended", "X", false, "Enable extended output")

cmd/tablizer.go

@@ -1,4 +1,5 @@
 package cmd
+
 var manpage = `
 NAME
     tablizer - Manipulate tabular output of other programs
@@ -20,7 +21,11 @@ SYNOPSIS
           -M, --markdown           Enable markdown table output
           -O, --orgtbl             Enable org-mode table output
           -s, --separator string   Custom field separator
+          -a, --sort-age           sort according to age (duration) string
           -k, --sort-by int        Sort by column (default: 1)
+          -D, --sort-desc          Sort in descending order (default: ascending)
+          -i, --sort-numeric       sort according to string numerical value
+          -t, --sort-time          sort according to time string
           -v, --version            Print program version
 
 DESCRIPTION
@@ -37,7 +42,7 @@ DESCRIPTION
 
     You can use tablizer to do these and more things.
 
-    tablizer analyses the header fiels of a table, registers the column
+    tablizer analyses the header fields of a table, registers the column
     positions of each header field and separates columns by those positions.
 
     Without any options it reads its input from "STDIN", but you can also
@@ -63,7 +68,7 @@ DESCRIPTION
        NAME(1) READY(2) STATUS(3) RESTARTS(4) AGE(5)
 
     These numbers denote the column and you can use them to specify which
-    columns you want to have in your output:
+    columns you want to have in your output (see COLUMNS:
 
        kubectl get pods | tablizer -c1,3
 
@@ -77,9 +82,20 @@ DESCRIPTION
 
     Use the -k option to specify by which column to sort the tabular data
     (as in GNU sort(1)). The default sort column is the first one. To
-    disable sorting at all, supply 0 (Zero) to -k.
+    disable sorting at all, supply 0 (Zero) to -k. The default sort order is
+    ascending. You can change this to descending order using the option -D.
+    The default sort order is by string, but there are other sort modes:
 
-    Finally the -d option enables debugging output which is mostly usefull
+    -a --sort-age
+        Sorts duration strings like "1d4h32m51s".
+
+    -i --sort-numeric
+        Sorts numeric fields.
+
+    -t --sort-time
+        Sorts timestamps.
+
+    Finally the -d option enables debugging output which is mostly useful
     for the developer.
 
   PATTERNS
@@ -102,14 +118,40 @@ DESCRIPTION
 
     "i" ignore case "m" multiline mode "s" single line mode
 
-    Example for a case insensitve search:
+    Example for a case insensitive search:
 
         kubectl get pods -A | tablizer "(?i)account"
 
+  COLUMNS
+    The parameter -c can be used to specify, which columns to display. By
+    default tablizer numerizes the header names and these numbers can be
+    used to specify which header to display, see example above.
+
+    However, beside numbers, you can also use regular expressions with -c,
+    also separated by comma. And you can mix column numbers with regexps.
+
+    Lets take this table:
+
+            PID TTY          TIME CMD
+          14001 pts/0    00:00:00 bash
+          42871 pts/0    00:00:00 ps
+          42872 pts/0    00:00:00 sed
+
+    We want to see only the CMD column and use a regex for this:
+
+        ps | tablizer -s '\s+' -c C
+        CMD(4)
+        bash
+        ps
+        tablizer
+        sed
+
+    where "C" is our regexp which matches CMD.
+
   OUTPUT MODES
     There might be cases when the tabular output of a program is way too
     large for your current terminal but you still need to see every column.
-    In such cases the -o extended or -X option can be usefull which enables
+    In such cases the -o extended or -X option can be useful which enables
     *extended mode*. In this mode, each row will be printed vertically,
     header left, value right, aligned by the field widths. Here's an
     example:

go.mod

@@ -4,15 +4,18 @@ go 1.18
 
 require (
 	github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897
+	github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de
 	github.com/gookit/color v1.5.2
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/spf13/cobra v1.5.0
-	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778
+	github.com/xhit/go-str2duration/v2 v2.0.0
 )
 
 require (
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
-	github.com/mattn/go-runewidth v0.0.9 // indirect
+	github.com/mattn/go-runewidth v0.0.10 // indirect
+	github.com/rivo/uniseg v0.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 // indirect
 	golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
 github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 h1:p9Sln00KOTlrYkxI1zYWl1QLnEqAqEARBEYa8FQnQcY=
 github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897/go.mod h1:xTS7Pm1pD1mvyM075QCDSRqH6qRLXylzS24ZTpRiSzQ=
+github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de h1:FxWPpzIjnTlhPwqqXc4/vE0f7GvRjuAsbW+HOIe8KnA=
+github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de/go.mod h1:DCaWoUhZrYW9p1lxo/cm8EmUOOzAPSEZNGF2DK1dJgw=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -8,22 +10,29 @@ github.com/gookit/color v1.5.2 h1:uLnfXcaFjlrDnQDT+NCBcfhrXqYTx/rcCa6xn01Y8yI=
 github.com/gookit/color v1.5.2/go.mod h1:w8h4bGiHeeBpvQVePTutdbERIUf3oJE5lZ8HM0UgXyg=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
+github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/scylladb/termtables v0.0.0-20191203121021-c4c0b6d42ff4/go.mod h1:C1a7PQSMz9NShzorzCiG2fk9+xuCgLkPeCvMHYR2OWg=
 github.com/spf13/cobra v1.5.0 h1:X+jTBEBqF0bHN+9cSMgmfuvv2VHJ9ezmFNf9Y/XstYU=
 github.com/spf13/cobra v1.5.0/go.mod h1:dWXEIy2H428czQCjInthrTRUg7yKbok+2Qi/yBIJoUM=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/xhit/go-str2duration/v2 v2.0.0 h1:uFtk6FWB375bP7ewQl+/1wBcn840GPhnySOdcz/okPE=
+github.com/xhit/go-str2duration/v2 v2.0.0/go.mod h1:ohY8p+0f07DiV6Em5LKB0s2YpLtXVyJfNt1+BlmyAsU=
 github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHgvgickp1Yw510KJOqX7H24mg8=
 github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44 h1:Bli41pIlzTzf3KEY06n+xnzK/BESIg2ze4Pgfh/aI8c=

lib/common.go

@@ -52,13 +52,13 @@ var (
 
 	// colors to be used per supported color mode
 	Colors = map[color.Level]map[string]string{
-		color.Level16: map[string]string{
+		color.Level16: {
 			"bg": "green", "fg": "black",
 		},
-		color.Level256: map[string]string{
+		color.Level256: {
 			"bg": "lightGreen", "fg": "black",
 		},
-		color.LevelRgb: map[string]string{
+		color.LevelRgb: {
 			// FIXME: maybe use something nicer
 			"bg": "lightGreen", "fg": "black",
 		},
@@ -68,7 +68,7 @@ var (
 	validOutputmodes = "(orgtbl|markdown|extended|ascii)"
 
 	// main program version
-	Version = "v1.0.8"
+	Version = "v1.0.10"
 
 	// generated  version string, used  by -v contains  lib.Version on
 	//  main  branch,   and  lib.Version-$branch-$lastcommit-$date  on
@@ -77,6 +77,12 @@ var (
 
 	// sorting
 	SortByColumn   int
+	SortDescending bool
+
+	SortNumeric bool
+	SortTime    bool
+	SortAge     bool
+	SortMode    string
 )
 
 // contains a whole parsed table

lib/helpers.go

@@ -23,6 +23,7 @@ import (
 	"github.com/gookit/color"
 	"os"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 )
@@ -36,22 +37,59 @@ func contains(s []int, e int) bool {
 	return false
 }
 
-func PrepareColumns() error {
+// parse columns list given with -c
+func PrepareColumns(data *Tabdata) error {
+	UseColumns = nil
 	if len(Columns) > 0 {
 		for _, use := range strings.Split(Columns, ",") {
+			if len(use) == 0 {
+				msg := fmt.Sprintf("Could not parse columns list %s: empty column", Columns)
+				return errors.New(msg)
+			}
+
 			usenum, err := strconv.Atoi(use)
+			if err != nil {
+				// might be a regexp
+				colPattern, err := regexp.Compile(use)
 				if err != nil {
 					msg := fmt.Sprintf("Could not parse columns list %s: %v", Columns, err)
 					return errors.New(msg)
 				}
+
+				// find matching header fields
+				for i, head := range data.headers {
+					if colPattern.MatchString(head) {
+						UseColumns = append(UseColumns, i+1)
+					}
+
+				}
+			} else {
+				// we digress from go  best practises here, because if
+				// a colum spec is not a number, we process them above
+				// inside the err handler  for atoi(). so only add the
+				// number, if it's really just a number.
 				UseColumns = append(UseColumns, usenum)
 			}
 		}
+
+		// deduplicate: put all values into a map (value gets map key)
+		// thereby  removing duplicates,  extract keys into  new slice
+		// and sort it
+		imap := make(map[int]int, len(UseColumns))
+		for _, i := range UseColumns {
+			imap[i] = 0
+		}
+		UseColumns = nil
+		for k := range imap {
+			UseColumns = append(UseColumns, k)
+		}
+		sort.Ints(UseColumns)
+	}
 	return nil
 }
 
+// prepare headers: add numbers to headers
 func numberizeHeaders(data *Tabdata) {
-	// prepare headers: add numbers to headers
 	numberedHeaders := []string{}
 	maxwidth := 0 // start from scratch, so we only look at displayed column widths
 
@@ -83,11 +121,11 @@ func numberizeHeaders(data *Tabdata) {
 	}
 }
 
+// exclude columns, if any
 func reduceColumns(data *Tabdata) {
-	// exclude columns, if any
 	if len(Columns) > 0 {
 		reducedEntries := [][]string{}
-		reducedEntry := []string{}
+		var reducedEntry []string
 		for _, entry := range data.entries {
 			reducedEntry = nil
 			for i, value := range entry {
@@ -136,6 +174,19 @@ func PrepareModeFlags() error {
 	return nil
 }
 
+func PrepareSortFlags() {
+	switch {
+	case SortNumeric:
+		SortMode = "numeric"
+	case SortAge:
+		SortMode = "duration"
+	case SortTime:
+		SortMode = "time"
+	default:
+		SortMode = "string"
+	}
+}
+
 func trimRow(row []string) []string {
 	// FIXME: remove this when we only use Tablewriter and strip in ParseFile()!
 	var fixedrow []string

lib/helpers_test.go

@@ -45,6 +45,23 @@ func Testcontains(t *testing.T) {
 }
 
 func TestPrepareColumns(t *testing.T) {
+	data := Tabdata{
+		maxwidthHeader: 5,
+		maxwidthPerCol: []int{
+			5,
+			5,
+			8,
+		},
+		columns: 3,
+		headers: []string{
+			"ONE", "TWO", "THREE",
+		},
+		entries: [][]string{
+			{
+				"2", "3", "4",
+			},
+		},
+	}
 	var tests = []struct {
 		input     string
 		exp       []int
@@ -52,14 +69,15 @@ func TestPrepareColumns(t *testing.T) {
 	}{
 		{"1,2,3", []int{1, 2, 3}, false},
 		{"1,2,", []int{}, true},
-		{"a,b", []int{}, true},
+		{"T", []int{2, 3}, false},
+		{"T,2,3", []int{2, 3}, false},
 	}
 
 	for _, tt := range tests {
 		testname := fmt.Sprintf("PrepareColumns-%s-%t", tt.input, tt.wanterror)
 		t.Run(testname, func(t *testing.T) {
 			Columns = tt.input
-			err := PrepareColumns()
+			err := PrepareColumns(&data)
 			if err != nil {
 				if !tt.wanterror {
 					t.Errorf("got error: %v", err)
@@ -79,15 +97,15 @@ func TestReduceColumns(t *testing.T) {
 		columns []int
 	}{
 		{
-			expect:  [][]string{[]string{"a", "b"}},
+			expect:  [][]string{{"a", "b"}},
 			columns: []int{1, 2},
 		},
 		{
-			expect:  [][]string{[]string{"a", "c"}},
+			expect:  [][]string{{"a", "c"}},
 			columns: []int{1, 3},
 		},
 		{
-			expect:  [][]string{[]string{"a"}},
+			expect:  [][]string{{"a"}},
 			columns: []int{1},
 		},
 		{
@@ -96,7 +114,7 @@ func TestReduceColumns(t *testing.T) {
 		},
 	}
 
-	input := [][]string{[]string{"a", "b", "c"}}
+	input := [][]string{{"a", "b", "c"}}
 
 	Columns = "y" // used as a flag with len(Columns)...
 

lib/io.go

@@ -44,6 +44,12 @@ func ProcessFiles(args []string) error {
 		if err != nil {
 			return err
 		}
+
+		err = PrepareColumns(&data)
+		if err != nil {
+			return err
+		}
+
 		printData(&data)
 	}
 

lib/parser.go

@@ -105,6 +105,12 @@ func parseFile(input io.Reader, pattern string) (Tabdata, error) {
 
 				idx++
 			}
+
+			// fill up missing fields, if any
+			for i := len(values); i < len(data.headers); i++ {
+				values = append(values, "")
+			}
+
 			data.entries = append(data.entries, values)
 		}
 	}

lib/parser_test.go

@@ -35,10 +35,10 @@ func TestParser(t *testing.T) {
 			"ONE", "TWO", "THREE",
 		},
 		entries: [][]string{
-			[]string{
+			{
 				"asd", "igig", "cxxxncnc",
 			},
-			[]string{
+			{
 				"19191", "EDD 1", "X",
 			},
 		},
@@ -69,7 +69,7 @@ func TestParserPatternmatching(t *testing.T) {
 	}{
 		{
 			entries: [][]string{
-				[]string{
+				{
 					"asd", "igig", "cxxxncnc",
 				},
 			},
@@ -78,7 +78,7 @@ func TestParserPatternmatching(t *testing.T) {
 		},
 		{
 			entries: [][]string{
-				[]string{
+				{
 					"19191", "EDD 1", "X",
 				},
 			},
@@ -92,7 +92,7 @@ asd    igig   cxxxncnc
 19191  EDD 1  X`
 
 	for _, tt := range tests {
-		testname := fmt.Sprintf("parse-with-inverted-pattern-%t", tt.invert)
+		testname := fmt.Sprintf("parse-with-pattern-%s-inverted-%t", tt.pattern, tt.invert)
 		t.Run(testname, func(t *testing.T) {
 			InvertMatch = tt.invert
 
@@ -110,3 +110,41 @@ asd    igig   cxxxncnc
 		})
 	}
 }
+
+func TestParserIncompleteRows(t *testing.T) {
+	data := Tabdata{
+		maxwidthHeader: 5,
+		maxwidthPerCol: []int{
+			5, 5, 1,
+		},
+		columns: 3,
+		headers: []string{
+			"ONE", "TWO", "THREE",
+		},
+		entries: [][]string{
+			{
+				"asd", "igig", "",
+			},
+			{
+				"19191", "EDD 1", "X",
+			},
+		},
+	}
+
+	table := `ONE    TWO    THREE  
+asd    igig
+19191  EDD 1  X`
+
+	readFd := strings.NewReader(table)
+	gotdata, err := parseFile(readFd, "")
+	Separator = DefaultSeparator
+
+	if err != nil {
+		t.Errorf("Parser returned error: %s\nData processed so far: %+v", err, gotdata)
+	}
+
+	if !reflect.DeepEqual(data, gotdata) {
+		t.Errorf("Parser returned invalid data, Regex: %s\nExp: %+v\nGot: %+v\n",
+			Separator, data, gotdata)
+	}
+}

lib/printer_test.go

@@ -52,10 +52,10 @@ func TestPrinter(t *testing.T) {
 			"ONE", "TWO", "THREE",
 		},
 		entries: [][]string{
-			[]string{
+			{
 				"asd", "igig", "cxxxncnc",
 			},
-			[]string{
+			{
 				"19191", "EDD 1", "X",
 			},
 		},
@@ -100,7 +100,9 @@ THREE(3): X`,
 		t.Run(testname, func(t *testing.T) {
 
 			OutputMode = mode
-			data := startdata // we need to reset our mock data, since it's being modified in printData()
+			//  we need  to reset  our  mock data,  since it's  being
+			// modified in printData()
+			data := startdata
 			printData(&data)
 
 			buf := make([]byte, 1024)
@@ -136,13 +138,13 @@ func TestSortPrinter(t *testing.T) {
 			"ONE", "TWO", "THREE",
 		},
 		entries: [][]string{
-			[]string{
+			{
 				"abc", "345", "b1",
 			},
-			[]string{
+			{
 				"bcd", "234", "a2",
 			},
-			[]string{
+			{
 				"cde", "123", "c3",
 			},
 		},
@@ -151,11 +153,13 @@ func TestSortPrinter(t *testing.T) {
 	var tests = []struct {
 		data   Tabdata
 		sortby int
+		desc   bool
 		expect string
 	}{
 		{
 			data:   startdata,
 			sortby: 1,
+			desc:   false,
 			expect: `ONE(1)	TWO(2)	THREE(3) 
 abc   	345   	b1      	
 bcd   	234   	a2      	
@@ -165,6 +169,7 @@ cde   	123   	c3`,
 		{
 			data:   startdata,
 			sortby: 2,
+			desc:   false,
 			expect: `ONE(1)	TWO(2)	THREE(3) 
 cde   	123   	c3      	
 bcd   	234   	a2      	
@@ -174,11 +179,21 @@ abc   	345   	b1`,
 		{
 			data:   startdata,
 			sortby: 3,
+			desc:   false,
 			expect: `ONE(1)	TWO(2)	THREE(3) 
 bcd   	234   	a2      	
 abc   	345   	b1      	
 cde   	123   	c3`,
 		},
+		{
+			data:   startdata,
+			sortby: 1,
+			desc:   true,
+			expect: `ONE(1)	TWO(2)	THREE(3) 
+cde   	123   	c3      	
+bcd   	234   	a2      	
+abc   	345   	b1`,
+		},
 	}
 
 	NoColor = true
@@ -186,9 +201,11 @@ cde   	123   	c3`,
 	origStdout, reader := stdout2pipe(t)
 
 	for _, tt := range tests {
-		testname := fmt.Sprintf("print-sorted-table-%d", tt.sortby)
+		testname := fmt.Sprintf("print-sorted-table-by-column-%d-desc-%t",
+			tt.sortby, tt.desc)
 		t.Run(testname, func(t *testing.T) {
 			SortByColumn = tt.sortby
+			SortDescending = tt.desc
 
 			printData(&tt.data)
 
@@ -210,3 +227,111 @@ cde   	123   	c3`,
 	// Restore
 	os.Stdout = origStdout
 }
+
+func TestSortByPrinter(t *testing.T) {
+	data := Tabdata{
+		maxwidthHeader: 8,
+		maxwidthPerCol: []int{
+			5,
+			9,
+			3,
+			26,
+		},
+		columns: 4,
+		headers: []string{
+			"NAME",
+			"DURATION",
+			"COUNT",
+			"WHEN",
+		},
+		entries: [][]string{
+			{
+				"beta",
+				"1d10h5m1s",
+				"33",
+				"3/1/2014",
+			},
+			{
+				"alpha",
+				"4h35m",
+				"170",
+				"2013-Feb-03",
+			},
+			{
+				"ceta",
+				"33d12h",
+				"9",
+				"06/Jan/2008 15:04:05 -0700",
+			},
+		},
+	}
+
+	var tests = []struct {
+		sortby string
+		column int
+		desc   bool
+		expect string
+	}{
+		{
+			column: 3,
+			sortby: "numeric",
+			desc:   false,
+			expect: `NAME(1)	DURATION(2)	COUNT(3)	WHEN(4)                    
+ceta   	33d12h     	9       	06/Jan/2008 15:04:05 -0700	
+beta   	1d10h5m1s  	33      	3/1/2014                  	
+alpha  	4h35m      	170     	2013-Feb-03`,
+		},
+		{
+			column: 2,
+			sortby: "duration",
+			desc:   false,
+			expect: `NAME(1)	DURATION(2)	COUNT(3)	WHEN(4)                    
+alpha  	4h35m      	170     	2013-Feb-03               	
+beta   	1d10h5m1s  	33      	3/1/2014                  	
+ceta   	33d12h     	9       	06/Jan/2008 15:04:05 -0700`,
+		},
+		{
+			column: 4,
+			sortby: "time",
+			desc:   false,
+			expect: `NAME(1)	DURATION(2)	COUNT(3)	WHEN(4)                    
+ceta   	33d12h     	9       	06/Jan/2008 15:04:05 -0700	
+alpha  	4h35m      	170     	2013-Feb-03               	
+beta   	1d10h5m1s  	33      	3/1/2014`,
+		},
+	}
+
+	NoColor = true
+	OutputMode = "ascii"
+	origStdout, reader := stdout2pipe(t)
+
+	for _, tt := range tests {
+		testname := fmt.Sprintf("print-sorted-table-by-column-%d-desc-%t-sort-by-%s",
+			tt.column, tt.desc, tt.sortby)
+
+		t.Run(testname, func(t *testing.T) {
+			SortByColumn = tt.column
+			SortDescending = tt.desc
+			SortMode = tt.sortby
+
+			testdata := data
+			printData(&testdata)
+
+			buf := make([]byte, 1024)
+			n, err := reader.Read(buf)
+			if err != nil {
+				t.Fatal(err)
+			}
+			buf = buf[:n]
+			output := strings.TrimSpace(string(buf))
+
+			if output != tt.expect {
+				t.Errorf("sort column: %d, sortby: %s, got:\n%s\nwant:\n%s",
+					tt.column, tt.sortby, output, tt.expect)
+			}
+		})
+	}
+
+	// Restore
+	os.Stdout = origStdout
+}

lib/sort.go

@@ -18,7 +18,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 package lib
 
 import (
+	"github.com/araddon/dateparse"
+	str2duration "github.com/xhit/go-str2duration/v2"
 	"sort"
+	"strconv"
 )
 
 func sortTable(data *Tabdata, col int) {
@@ -41,6 +44,45 @@ func sortTable(data *Tabdata, col int) {
 
 	// actual sorting
 	sort.SliceStable(data.entries, func(i, j int) bool {
-		return data.entries[i][col] < data.entries[j][col]
+		return compare(data.entries[i][col], data.entries[j][col])
 	})
 }
+
+func compare(a string, b string) bool {
+	var comp bool
+
+	switch SortMode {
+	case "numeric":
+		left, err := strconv.Atoi(a)
+		if err != nil {
+			left = 0
+		}
+		right, err := strconv.Atoi(b)
+		if err != nil {
+			right = 0
+		}
+		comp = left < right
+	case "duration":
+		left, err := str2duration.ParseDuration(a)
+		if err != nil {
+			left = 0
+		}
+		right, err := str2duration.ParseDuration(b)
+		if err != nil {
+			right = 0
+		}
+		comp = left.Seconds() < right.Seconds()
+	case "time":
+		left, _ := dateparse.ParseAny(a)
+		right, _ := dateparse.ParseAny(b)
+		comp = left.Unix() < right.Unix()
+	default:
+		comp = a < b
+	}
+
+	if SortDescending {
+		comp = !comp
+	}
+
+	return comp
+}

tablizer.1

@@ -133,7 +133,7 @@
 .\" ========================================================================
 .\"
 .IX Title "TABLIZER 1"
-.TH TABLIZER 1 "2022-10-13" "1" "User Commands"
+.TH TABLIZER 1 "2022-10-15" "1" "User Commands"
 .\" For nroff, turn off justification.  Always turn off hyphenation; it makes
 .\" way too many mistakes in technical documents.
 .if n .ad l
@@ -159,7 +159,11 @@ tablizer \- Manipulate tabular output of other programs
 \&      \-M, \-\-markdown           Enable markdown table output
 \&      \-O, \-\-orgtbl             Enable org\-mode table output
 \&      \-s, \-\-separator string   Custom field separator
+\&      \-a, \-\-sort\-age           sort according to age (duration) string
 \&      \-k, \-\-sort\-by int        Sort by column (default: 1)
+\&      \-D, \-\-sort\-desc          Sort in descending order (default: ascending)
+\&      \-i, \-\-sort\-numeric       sort according to string numerical value
+\&      \-t, \-\-sort\-time          sort according to time string
 \&      \-v, \-\-version            Print program version
 .Ve
 .SH "DESCRIPTION"
@@ -177,8 +181,8 @@ not easy to process.
 .PP
 You can use \fBtablizer\fR to do these and more things.
 .PP
-\&\fBtablizer\fR analyses the header fiels of a table, registers the column
-positions  of  each  header  field  and  separates  columns  by  those
+\&\fBtablizer\fR  analyses the  header  fields of  a  table, registers  the
+column positions of  each header field and separates  columns by those
 positions.
 .PP
 Without any options it reads its input from \f(CW\*(C`STDIN\*(C'\fR, but you can also
@@ -209,7 +213,7 @@ have a numer associated with it, e.g.:
 .Ve
 .PP
 These numbers denote the column and  you can use them to specify which
-columns you want to have in your output:
+columns you want to have in your output (see \s-1COLUMNS\s0:
 .PP
 .Vb 1
 \&   kubectl get pods | tablizer \-c1,3
@@ -225,10 +229,22 @@ highlighted. You can disable this behavior with the \fB\-N\fR option.
 .PP
 Use the  \fB\-k\fR option to specify  by which column to  sort the tabular
 data (as in \s-1GNU\s0 \fBsort\fR\|(1)). The default sort column is the first one. To
-disable sorting at all, supply 0 (Zero) to \-k.
+disable sorting at all, supply 0  (Zero) to \-k. The default sort order
+is ascending. You can change this to descending order using the option
+\&\fB\-D\fR. The default  sort order is by string, but  there are other sort
+modes:
+.IP "\fB\-a \-\-sort\-age\fR" 4
+.IX Item "-a --sort-age"
+Sorts duration strings like \*(L"1d4h32m51s\*(R".
+.IP "\fB\-i \-\-sort\-numeric\fR" 4
+.IX Item "-i --sort-numeric"
+Sorts numeric fields.
+.IP "\fB\-t \-\-sort\-time\fR" 4
+.IX Item "-t --sort-time"
+Sorts timestamps.
 .PP
 Finally the  \fB\-d\fR option  enables debugging  output which  is mostly
-usefull for the developer.
+useful for the developer.
 .SS "\s-1PATTERNS\s0"
 .IX Subsection "PATTERNS"
 You can reduce the rows being  displayed by using a regular expression
@@ -256,17 +272,49 @@ The most important modifiers are:
 \&\f(CW\*(C`m\*(C'\fR multiline mode
 \&\f(CW\*(C`s\*(C'\fR single line mode
 .PP
-Example for a case insensitve search:
+Example for a case insensitive search:
 .PP
 .Vb 1
 \&    kubectl get pods \-A | tablizer "(?i)account"
 .Ve
+.SS "\s-1COLUMNS\s0"
+.IX Subsection "COLUMNS"
+The  parameter  \fB\-c\fR  can  be  used  to  specify,  which  columns  to
+display.  By default  tablizer numerizes  the header  names and  these
+numbers can  be used to specify  which header to display,  see example
+above.
+.PP
+However, beside  numbers, you  can also  use regular  expressions with
+\&\fB\-c\fR, also  separated by comma. And  you can mix column  numbers with
+regexps.
+.PP
+Lets take this table:
+.PP
+.Vb 4
+\&        PID TTY          TIME CMD
+\&      14001 pts/0    00:00:00 bash
+\&      42871 pts/0    00:00:00 ps
+\&      42872 pts/0    00:00:00 sed
+.Ve
+.PP
+We want to see only the \s-1CMD\s0 column and use a regex for this:
+.PP
+.Vb 6
+\&    ps | tablizer \-s \*(Aq\es+\*(Aq \-c C
+\&    CMD(4)
+\&    bash
+\&    ps
+\&    tablizer
+\&    sed
+.Ve
+.PP
+where \*(L"C\*(R" is our regexp which matches \s-1CMD.\s0
 .SS "\s-1OUTPUT MODES\s0"
 .IX Subsection "OUTPUT MODES"
 There might be cases  when the tabular output of a  program is way too
 large  for your  current  terminal but  you still  need  to see  every
 column.   In such  cases the  \fB\-o extended\fR  or \fB\-X\fR  option can  be
-usefull which enables \fIextended mode\fR. In this mode, each row will be
+useful which enables \fIextended mode\fR. In  this mode, each row will be
 printed vertically,  header left,  value right,  aligned by  the field
 widths. Here's an example:
 .PP

tablizer.pod

@@ -20,7 +20,11 @@ tablizer - Manipulate tabular output of other programs
       -M, --markdown           Enable markdown table output
       -O, --orgtbl             Enable org-mode table output
       -s, --separator string   Custom field separator
+      -a, --sort-age           sort according to age (duration) string
       -k, --sort-by int        Sort by column (default: 1)
+      -D, --sort-desc          Sort in descending order (default: ascending)
+      -i, --sort-numeric       sort according to string numerical value
+      -t, --sort-time          sort according to time string
       -v, --version            Print program version
 
 
@@ -39,8 +43,8 @@ not easy to process.
 
 You can use B<tablizer> to do these and more things.
 
-B<tablizer> analyses the header fiels of a table, registers the column
-positions  of  each  header  field  and  separates  columns  by  those
+B<tablizer>  analyses the  header  fields of  a  table, registers  the
+column positions of  each header field and separates  columns by those
 positions.
 
 Without any options it reads its input from C<STDIN>, but you can also
@@ -67,7 +71,7 @@ have a numer associated with it, e.g.:
    NAME(1) READY(2) STATUS(3) RESTARTS(4) AGE(5)
 
 These numbers denote the column and  you can use them to specify which
-columns you want to have in your output:
+columns you want to have in your output (see L<COLUMNS>:
 
    kubectl get pods | tablizer -c1,3
 
@@ -81,10 +85,29 @@ highlighted. You can disable this behavior with the B<-N> option.
 
 Use the  B<-k> option to specify  by which column to  sort the tabular
 data (as in GNU sort(1)). The default sort column is the first one. To
-disable sorting at all, supply 0 (Zero) to -k.
+disable sorting at all, supply 0  (Zero) to -k. The default sort order
+is ascending. You can change this to descending order using the option
+B<-D>. The default  sort order is by string, but  there are other sort
+modes:
+
+=over
+
+=item B<-a --sort-age>
+
+Sorts duration strings like "1d4h32m51s".
+
+=item B<-i --sort-numeric>
+
+Sorts numeric fields.
+
+=item B<-t --sort-time>
+
+Sorts timestamps.
+
+=back
 
 Finally the  B<-d> option  enables debugging  output which  is mostly
-usefull for the developer.
+useful for the developer.
 
 =head2 PATTERNS
 
@@ -109,17 +132,46 @@ C<i> ignore case
 C<m> multiline mode
 C<s> single line mode
 
-Example for a case insensitve search:
+Example for a case insensitive search:
 
     kubectl get pods -A | tablizer "(?i)account"
 
 
+=head2 COLUMNS
+
+The  parameter  B<-c>  can  be  used  to  specify,  which  columns  to
+display.  By default  tablizer numerizes  the header  names and  these
+numbers can  be used to specify  which header to display,  see example
+above.
+
+However, beside  numbers, you  can also  use regular  expressions with
+B<-c>, also  separated by comma. And  you can mix column  numbers with
+regexps.
+
+Lets take this table:
+
+        PID TTY          TIME CMD
+      14001 pts/0    00:00:00 bash
+      42871 pts/0    00:00:00 ps
+      42872 pts/0    00:00:00 sed
+
+We want to see only the CMD column and use a regex for this:
+
+    ps | tablizer -s '\s+' -c C
+    CMD(4)
+    bash
+    ps
+    tablizer
+    sed
+
+where "C" is our regexp which matches CMD.
+
 =head2 OUTPUT MODES
 
 There might be cases  when the tabular output of a  program is way too
 large  for your  current  terminal but  you still  need  to see  every
 column.   In such  cases the  B<-o extended>  or B<-X>  option can  be
-usefull which enables I<extended mode>. In this mode, each row will be
+useful which enables I<extended mode>. In  this mode, each row will be
 printed vertically,  header left,  value right,  aligned by  the field
 widths. Here's an example: