lib/argy/help.rb in argy-0.0.0 vs lib/argy/help.rb in argy-0.1.0

@@ -1,20 +1,13 @@
 module Argy
-  # Builds help information
   class Help
-    # Create a new Help
-    # @param parser [Parser] the parser to generate help for
-    # @param column [Integer] the column width of the help
-    # @param color [TrueClass,FalseClass] whether or not to print with color
     def initialize(parser, column: 30, color: $stdout.tty?)
       @parser = parser
       @column = column
       @color = color
     end
 
-    # The help information
-    # @return [String]
     def to_s
       out = []
 
       description(out)
       usage(out)
@@ -24,30 +17,10 @@
       flags(out)
 
       out.join("\n") + "\n"
     end
 
-    # Format the title of a custom section
-    # @return [String]
-    def section(title)
-      bold "\n#{title}"
-    end
-
-    # Format an entry of a section
-    # @param name [String] left column of the entry
-    # @param desc [String] right column of the entry
-    # @param required [TrueClass,FalseClass] whether or not the entry is required
-    # @param default [Object] default value for the entry
-    # @return [String]
-    def entry(name, desc: nil, required: false, default: nil)
-      out = "  #{name.ljust(column)}"
-      out += dim("#{desc} ") if desc
-      out += dim("(required) ") if required
-      out += dim("[default: #{default.inspect}]") if default
-      out.rstrip
-    end
-
     private
 
     def description(out)
       out << "#{parser.description}\n" if parser.description
     end
@@ -66,37 +39,46 @@
       out << bold("\nARGUMENTS") if parser.arguments.any?
       out.concat parser.arguments.map { |a| argument(a) }
     end
 
     def argument(a)
-      entry(a.label, desc: a.desc, required: a.required?, default: a.default)
+      parameter(a.label, a.desc, a.required?, a.default)
     end
 
     def options(out)
       out << bold("\nOPTIONS") if parser.options.any?
       out.concat parser.options.map { |o| option(o) }
     end
 
     def option(o)
       label = [option_label(o.label, o.type)]
       label += o.aliases.map { |a| option_label(a, o.type) }
-      entry(label.join(", "), desc: o.desc, required: o.required?, default: o.default)
+      parameter(label.join(", "), o.desc, o.required?, o.default)
     end
 
     def flags(out)
-      out << bold("\nFLAGS") if parser.flags.any?
+      out << bold("\nFLAGS")
       out.concat parser.flags.map { |f, _| flag(f) }
+      out << parameter("--help, -h", "show this help and exit")
     end
 
     def flag(flag)
       flag = flag.dup
       desc = flag.pop unless flag.last.match?(/^-/)
-      entry(flag.reverse.join(", "), desc: desc)
+      parameter(flag.reverse.join(", "), desc)
     end
 
     def option_label(label, type)
       return label if type == :boolean
       label.start_with?("--") ? "#{label}=VALUE" : "#{label} VALUE"
+    end
+
+    def parameter(left, right, required = false, default = nil)
+      label = "  #{left.ljust(column)}"
+      label += dim("#{right} ") if right
+      label += dim("(required) ") if required
+      label += dim("[default: #{default.inspect}]") if default
+      label.rstrip
     end
 
     def bold(text)
       color? ? "\e[1m#{text}\e[0m" : text
     end