shellopts 2.0.0.pre.13 → 2.0.1

data/lib/shellopts/renderer.rb

@@ -0,0 +1,227 @@
+require 'terminfo'
+
+# Option rendering
+#   -a, --all                   # Only used in brief and doc formats (enum)
+#   --all                       # Only used in usage (long)
+#   -a                          # Only used in usage (short)
+#
+# Option group rendering
+#   -a, --all  -b, --beta       # Only used in brief formats (enum)
+#   --all --beta                # Used in usage (long)
+#   -a -b                       # Used in usage (short)
+#
+#   -a, --all                   # Only used in doc format (:multi)
+#   -b, --beta
+#
+# Command rendering
+#   cmd --all --beta [cmd1|cmd2] ARG1 ARG2    # Single-line formats (:single)
+#   cmd --all --beta [cmd1|cmd2] ARGS...     
+#   cmd -a -b [cmd1|cmd2] ARG1 ARG2
+#   cmd -a -b [cmd1|cmd2] ARGS...
+#
+#   cmd -a -b [cmd1|cmd2] ARG1 ARG2           # One line for each argument description (:enum)
+#   cmd -a -b [cmd1|cmd2] ARG3 ARG4           # (used in the USAGE section)
+#
+#   cmd --all --beta                          # Multi-line formats (:multi)
+#       [cmd1|cmd2] ARG1 ARG2
+#   cmd --all --beta
+#       <commands> ARGS
+#   
+module ShellOpts
+  module Grammar
+    class Option
+      # Formats:
+      #
+      #   :enum     -a, --all
+      #   :long     --all
+      #   :short    -a
+      #
+      def render(format)
+        constrain format, :enum, :long, :short
+        case format
+          when :enum; names.join(", ")
+          when :long; name
+          when :short; short_names.first || name
+        else
+          raise ArgumentError, "Illegal format: #{format.inspect}"
+        end + (argument? ? "=#{argument_name}" : "")
+      end
+    end
+
+    class OptionGroup
+      # Formats:
+      #     
+      #     :enum   -a, --all -r, --recursive
+      #     :long   --all --recursive
+      #     :short  -a -r
+      #     :multi  -a, --all
+      #             -r, --recursive
+      #
+      def render(format)
+        constrain format, :enum, :long, :short, :multi
+        if format == :multi
+          options.map { |option| option.render(:enum) }.join("\n")
+        else
+          options.map { |option| option.render(format) }.join(" ")
+        end
+      end
+    end
+
+    # brief one-line commands should optionally use compact options
+    class Command
+      using Ext::Array::Wrap
+
+      OPTIONS_ABBR = "[OPTIONS]"
+      COMMANDS_ABBR = "[COMMANDS]"
+      DESCRS_ABBR = "ARGS..."
+
+      # Format can be one of :single, :enum, or :multi. :single force one-line
+      # output and compacts options and commands if needed. :enum outputs a
+      # :single line for each argument specification/description, :multi tries
+      # one-line output but wrap options if needed. Multiple argument
+      # specifications/descriptions are always compacted
+      #
+      def render(format, width, root: false, **opts)
+        case format
+          when :single; render_single(width, **opts)
+          when :enum; render_enum(width, **opts)
+          when :multi; render_multi2(width, **opts)
+        else
+          raise ArgumentError, "Illegal format: #{format.inspect}"
+        end
+      end
+
+      def names(root: false)
+        (root ? ancestors : []) + [self]
+      end
+
+    protected
+      # Force one line. Compact options, commands, arguments if needed
+      def render_single(width, args: nil)
+        long_options = options.map { |option| option.render(:long) }
+        short_options = options.map { |option| option.render(:short) }
+        compact_options = options.empty? ? [] : [OPTIONS_ABBR]
+        short_commands = commands.empty? ? [] : ["[#{commands.map(&:name).join("|")}]"]
+        compact_commands = commands.empty? ? [] : [COMMANDS_ABBR]
+
+        # TODO: Refactor and implement recursive detection of any argument
+        args ||= 
+            case descrs.size
+              when 0; args = []
+              when 1; [descrs.first.text]
+              else [DESCRS_ABBR]
+            end
+
+        begin # to be able to use 'break' below
+          words = [name] + long_options + short_commands + args
+          break if pass?(words, width)
+          words = [name] + short_options + short_commands + args
+          break if pass?(words, width)
+          words = [name] + long_options + compact_commands + args
+          break if pass?(words, width)
+          words = [name] + short_options + compact_commands + args
+          break if pass?(words, width)
+          words = [name] + compact_options + short_commands + args
+          break if pass?(words, width)
+          words = [name] + compact_options + compact_commands + args
+          break if pass?(words, width)
+          words = [name] + compact_options + compact_commands + [DESCRS_ABBR]
+        end while false
+        words.join(" ")
+      end
+
+      # Render one line for each argument specification/description
+      def render_enum(width)
+        # TODO: Also refactor args here
+        args_texts = self.descrs.empty? ? [""] : descrs.map(&:text)
+        args_texts.map { |args_text| render_single(width, args: [args_text]) }
+      end
+
+      # Render the description using the given method (:single, :multi)
+      def render_descr(method, width, descr)
+        send.send method, width, args: descr
+      end
+
+      # Try to keep on one line but wrap options if needed. Multiple argument
+      # specifications/descriptions are always compacted
+      def render_multi(width, args: nil)
+        long_options = options.map { |option| option.render(:long) }
+        short_options = options.map { |option| option.render(:short) }
+        short_commands = commands.empty? ? [] : ["[#{commands.map(&:name).join("|")}]"]
+        compact_commands = [COMMANDS_ABBR]
+        args ||= self.descrs.size != 1 ? [DESCRS_ABBR] : descrs.map(&:text)
+
+        # On one line
+        words = long_options + short_commands + args
+        return [words.join(" ")] if pass?(words, width)
+        words = short_options + short_commands + args
+        return [words.join(" ")] if pass?(words, width)
+
+        # On multiple lines
+        options = long_options.wrap(width)
+        commands = [[short_commands, args].join(" ")]
+        return options + commands if pass?(commands, width)
+        options + [[compact_commands, args].join(" ")]
+      end
+
+      # Try to keep on one line but wrap options if needed. Multiple argument
+      # specifications/descriptions are always compacted
+      def render_multi2(width, args: nil)
+        long_options = options.map { |option| option.render(:long) }
+        short_options = options.map { |option| option.render(:short) }
+        short_commands = commands.empty? ? [] : ["[#{commands.map(&:name).join("|")}]"]
+        compact_commands = [COMMANDS_ABBR]
+
+        # TODO: Refactor and implement recursive detection of any argument
+        args ||= 
+            case descrs.size
+              when 0; args = []
+              when 1; [descrs.first.text]
+              else [DESCRS_ABBR]
+            end
+
+        # On one line
+        words = [name] + long_options + short_commands + args
+        return [words.join(" ")] if pass?(words, width)
+        words = [name] + short_options + short_commands + args
+        return [words.join(" ")] if pass?(words, width)
+
+        # On multiple lines
+        lead = name + " "
+        options = long_options.wrap(width - lead.size)
+        options = [lead + options[0]] + indent_lines(lead.size, options[1..-1])
+
+        begin
+          words = short_commands + args
+          break if pass?(words, width)
+          words = compact_commands + args
+          break if pass?(words, width)
+          words = compact_commands + [DESCRS_ABBR]
+        end while false
+
+        cmdargs = words.empty? ? [] : [words.join(" ")]
+        options + indent_lines(lead.size, cmdargs)
+      end
+
+    protected
+      # Helper method that returns true if words can fit in width characters
+      def pass?(words, width)
+        words.sum(&:size) + words.size - 1 <= width
+      end
+
+      # Indent array of lines
+      def indent_lines(indent, lines)
+        indent = [indent, 0].max
+        lines.map { |line| ' ' * indent + line }
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+

data/lib/shellopts/stack.rb

@@ -0,0 +1,7 @@
+module ShellOpts
+  module Stack
+    refine Array do
+      def top() last end
+    end
+  end
+end

data/lib/shellopts/token.rb

@@ -0,0 +1,44 @@
+
+module ShellOpts
+  class Token
+    # Each kind should have a corresponding Grammar class with the same name
+    KINDS = [
+        :program, :section, :option, :command, :spec, :argument, :usage,
+        :usage_string, :brief, :text, :blank 
+    ]
+
+    # Kind of token
+    attr_reader :kind
+
+    # Line number (one-based)
+    attr_reader :lineno
+
+    # Char number (one-based). The lexer may adjust the char number (eg. for
+    # blank lines)
+    attr_accessor :charno
+
+    # Source of the token
+    attr_reader :source
+
+    def initialize(kind, lineno, charno, source)
+      constrain kind, :program, *KINDS
+      @kind, @lineno, @charno, @source = kind, lineno, charno, source
+    end
+
+    forward_to :source, :to_s, :empty?
+
+    def pos(start_lineno = 1, start_charno = 1) 
+      "#{start_lineno + lineno - 1}:#{start_charno + charno - 1}" 
+    end
+
+    def to_s() source end
+
+    def inspect() 
+      "<#{self.class.to_s.sub(/.*::/, "")} #{pos} #{kind.inspect} #{source.inspect}>"
+    end
+
+    def dump
+      puts "#{kind}@#{lineno}:#{charno} #{source.inspect}"
+    end
+  end
+end

data/lib/shellopts/version.rb

@@ -1,3 +1,3 @@
-module Shellopts
-  VERSION = "2.0.0.pre.13"
+module ShellOpts
+  VERSION = "2.0.1"
 end