shellopts 2.0.0.pre.7 → 2.0.0.pre.14

data/lib/shellopts/exceptions.rb

@@ -0,0 +1,21 @@
+
+module ShellOpts
+  class CompileError < StandardError; end
+
+  class ShellOptsError < RuntimeError; end
+
+  class Error < ShellOptsError
+    attr_reader :subject
+
+    def initialize(subject = nil) 
+      super()
+      @subject = subject
+    end
+  end
+
+  class Fail < ShellOptsError; end
+end
+
+class NotYet < NotImplementedError; end
+class NotThis < ScriptError; end
+class NotHere < ScriptError; end

data/lib/shellopts/formatter.rb

@@ -0,0 +1,125 @@
+
+require 'ext/algorithm'
+
+require 'stringio'
+
+module ShellOpts
+  class Formatter
+    # Return string describing usage of command
+    def self.usage_string(command, levels: 1, margin: "")
+      elements(command, levels: levels, help: false).map { |line|
+        "#{margin}#{line}"
+      }.join("\n")
+    end
+
+    # Return string with help for the given command
+    def self.help_string(command, levels: 10, margin: "", tab: "  ")
+      io = StringIO.new
+      elements(command, levels: levels, help: true).each { |head, texts, options|
+        io.puts "#{margin}#{head}"
+        texts.each { |text| io.puts "#{margin}#{tab}#{text}" }
+        options.each { |opt_head, opt_texts|
+          io.puts
+          io.puts "#{margin}#{tab}#{opt_head}"
+          opt_texts.each { |text| io.puts "#{margin}#{tab*2}#{text}" }
+        }
+        io.puts
+      }
+      io.string[0..-2]
+    end
+
+  private
+    def self.elements(command, levels: 1, help: false)
+      result = []
+      recursive_elements(result, command, levels: levels, help: help)
+      result  
+    end
+
+    def self.recursive_elements(acc, command, levels: 1, help: false)
+      cmds = (command.virtual? ? command.cmds : [command])
+      cmds.each { |cmd|
+        if levels == 1 || cmd.cmds.empty?
+          usage = (
+              path_elements(cmd) + 
+              option_elements(cmd) +
+              subcommand_element(cmd) +
+              argument_elements(cmd)
+          ).compact.join(" ")
+          if help
+            opts = []
+            cmd.opts.each { |opt|
+              next if opt.text.empty?
+              opts << [option_help(opt), opt.text]
+            }
+            acc << [usage, cmd.text, opts]
+          else
+            acc << usage
+          end
+        else
+          cmd.cmds.each { |subcmd|
+            recursive_elements(acc, subcmd, levels: levels - 1, help: help)
+          }
+        end
+      }
+    end
+
+    # Return command line usage string
+    def self.command(cmd)
+      (path_elements(cmd) + option_elements(cmd) + argument_elements(cmd)).compact.join(" ")
+    end
+
+    def self.path_elements(cmd)
+      Algorithm.follow(cmd, :parent).map { |parent| parent.name }.reverse
+    end
+
+    def self.option_elements(cmd)
+      elements = []
+      collapsable_opts, other_opts = cmd.opts.partition { |opt| opt.shortname && !opt.argument? }
+
+      if !collapsable_opts.empty?
+        elements << "-" + collapsable_opts.map(&:shortname).join
+      end
+
+      elements + other_opts.map { |opt|
+        if opt.shortname
+          "-#{opt.shortname} #{opt.argument_name}" # We know opt has an argument
+        elsif opt.argument?
+          "--#{opt.longname}=#{opt.argument_name}"
+        else
+          "--#{opt.longname}"
+        end
+      }
+    end
+
+    def self.option_help(opt)
+      result = opt.names.map { |name|
+        if name.size == 1
+          "-#{name}"
+        else
+          "--#{name}"
+        end
+      }.join(", ")
+      if opt.argument?
+        if opt.longname
+          result += "=#{opt.argument_name}"
+        else
+          result += " #{opt.argument_name}"
+        end
+      end
+      result
+    end
+
+    def self.subcommand_element(cmd)
+      !cmd.cmds.empty? ? [cmd.cmds.map(&:name).join("|")] : []
+    end
+
+    def self.argument_elements(cmd)
+      cmd.args
+    end
+
+    def self.help_element(cmd)
+      text.map { |l| l.sub(/^\s*# /, "").rstrip }.join(" ")
+    end
+  end
+end
+

data/lib/shellopts/grammar/analyzer.rb

@@ -0,0 +1,76 @@
+
+module ShellOpts
+  module Grammar
+    class Analyzer
+      def self.analyze(commands)
+        @program = commands.shift
+        @commands = commands
+        build_options
+        link_up
+        @program
+      end
+
+    private
+      def self.error(mesg, command)
+        mesg += " in #{command.path}" if !command.program?
+        raise CompileError, mesg
+      end
+
+      def self.program() @program end
+      def self.commands() @commands end
+
+      # Initialize Command#options
+      def self.build_options
+        ([program] + commands).each { |command|
+          command.opts.each { |opt|
+            opt.names.each { |name|
+              !command.options.key?(name) or 
+                  error "Duplicate option name '#{name}'", command
+              command.options[name] = opt
+            }
+
+            !command.options.key?(opt.ident) or 
+                error "Duplicate option identifier '#{opt.ident}'", command
+            command.options[opt.ident] = opt
+          }
+        }
+      end
+
+      # Initialize Command#commands
+      def self.link_up
+        # Hash from path to command
+        cmds = { "" => program }
+
+        # Add placeholders for actual commands and virtual commands for empty parent commands
+        commands.sort.each { |cmd|
+          # Place holder for actual command
+          cmds[cmd.path] = nil
+
+          # Add parent virtual commands 
+          curr = cmd
+          while !cmds.key?(curr.parent_path)
+            curr = cmds[curr.parent_path] = VirtualCommand.new(curr.parent_path)
+          end
+        }
+
+        # Add actual commands
+        commands.sort.each { |cmd|
+          !cmds[cmd.path] or 
+              error "Duplicate command name '#{cmd.name}'", cmds[cmd.parent_path]
+          cmds[cmd.path] = cmd
+        }
+
+        # Link up
+        cmds.values.each { |cmd|
+          next if cmd == program
+          cmd.instance_variable_set(:@parent, cmds[cmd.parent_path])
+          cmd.parent.commands[cmd.name] = cmd
+          cmd.parent.cmds << cmd
+          !cmd.parent.commands.key?(cmd.ident) or 
+              error "Duplicate command identifier '#{cmd.ident}'", cmd.parent
+          cmd.parent.commands[cmd.ident] = cmd
+        }
+      end
+    end
+  end
+end

data/lib/shellopts/grammar/command.rb

@@ -1,80 +1,87 @@
 module ShellOpts
   module Grammar
-    # A command. Commands are organized hierarchically with a Program object as
-    # the root node
-    #
-    # Sets Node#key to the name of the command incl. the exclamation point
-    class Command < Node
-      # Parent command. Nil if this is the top level command (the program)
+    # TODO: Command aliases: list.something!,list.somethingelse!
+    class Command
+      # Parent command. nil for the program-level Command object. Initialized
+      # by the analyzer
       attr_reader :parent
 
-      # Name of command (String). Name doesn't include the exclamation point ('!')
+      # Name of command. nil for the program-level Command object
       attr_reader :name
 
-      # Same as #name. TODO Define in Grammar::Node instead
-      alias :key_name :name
+      # Ident of command. nil for the program-level Command object
+      attr_reader :ident
 
-      # List of options in declaration order
-      attr_reader :option_list
+      # Path of command. The empty string for the program-level Command object
+      attr_reader :path
 
-      # List of commands in declaration order
-      attr_reader :subcommand_list
+      # Path of parent command. nil for the program-level Command object. This
+      # is the same as #parent&.path but is available before #parent is
+      # intialized. It is used to build the command hierarchy in the analyzer
+      attr_reader :parent_path
 
-      # Multihash from option key or names (both short and long names) to option. This
-      # means an option can occur more than once as the hash value
-      def options() 
-        @option_multihash ||= @option_list.flat_map { |option| 
-          option.identifiers.map { |ident| [ident, option] }
-        }.to_h
-      end
+      # List of comments. Initialized by the parser
+      attr_reader :text 
 
-      # Sub-commands of this command. Is a multihash from sub-command key or
-      # name to command object. Lazily constructed because subcommands are added
-      # after initialization
-      def subcommands()
-        @subcommand_multihash ||= @subcommand_list.flat_map { |subcommand| 
-          subcommand.identifiers.map { |name| [name, subcommand] }
-        }.to_h
-      end
+      # List of options. Initialized by the parser
+      attr_reader :opts 
 
-      # Initialize a Command object. parent is the parent Command object or nil
-      # if this is the root object. name is the name of the command (without
-      # the exclamation mark), and option_list a list of Option objects
-      def initialize(parent, name, option_list)
-        super("#{name}!".to_sym, name)
-        parent.attach(self) if parent
-        @option_list = option_list
-        @subcommand_list = []
-      end
+      # List of sub-commands. Initialized by the parser
+      attr_reader :cmds 
+
+      # List of arguments. Initialized by the parser
+      attr_reader :args
+
+      # Hash from name/identifier to option. Note that each option has at least
+      # two entries in the hash: One by name and one by identifier. Option
+      # aliases are also keys in the hash. Initialized by the analyzer
+      attr_reader :options 
+
+      # Hash from name to sub-command. Note that each command has two entries in
+      # the hash: One by name and one by identifier. Initialized by the analyzer
+      attr_reader :commands 
 
-      # Return key for the identifier
-      def identifier2key(ident)
-        options[ident]&.key || subcommands[ident]&.key
+      def initialize(path, virtual: false)
+        if path == ""
+          @path = path
+        else
+          @path = path.sub(/!$/, "")
+          components = @path.split(".")
+          @name = components.pop
+          @parent_path = components.join(".")
+          @ident = @name.gsub(/-/, "_").to_sym
+        end
+        @virtual = virtual
+        @text = []
+        @opts = []
+        @cmds = []
+        @args = []
+
+        @options = {}
+        @commands = {}
       end
 
-      # Return list of identifiers for the command
-      def identifiers() [key, name] end
-
-      # :nocov:
-      def dump(&block)
-        puts "#{key.inspect}"
-        indent {
-          puts "parent: #{parent&.key.inspect}"
-          puts "name: #{name.inspect}"
-          yield if block_given?
-          puts "options:"
-          indent { option_list.each { |opt| opt.dump } }
-          puts "subcommands: "
-          indent { subcommand_list.each { |cmd| cmd.dump } }
-        }
+      # True if this is the program-level command
+      def program?() @path == "" end
+
+      # True if this is a virtual command that cannot be called without a
+      # sub-command
+      def virtual?() @virtual end
+
+      def <=>(other)
+        path <=> other.path
       end
-      # :nocov:
+    end
 
-    protected
-      def attach(subcommand)
-        subcommand.instance_variable_set(:@parent, self)
-        @subcommand_list << subcommand
+    class Program < Command
+      def initialize(name) 
+        super("") 
+        @name = name
       end
     end
+
+    class VirtualCommand < Command
+      def initialize(path) super(path, virtual: true) end
+    end
   end
 end

data/lib/shellopts/grammar/dump.rb

@@ -0,0 +1,56 @@
+module ShellOpts
+  module Grammar
+    class Command
+      def dump
+        print (path ? "#{path}!" : 'nil')
+        print " (virtual)" if virtual?
+        print " [PROGRAM]" if program?
+        puts
+        indent {
+          puts "name: #{name.inspect}"
+          puts "ident: #{ident.inspect}"
+          puts "path: #{path.inspect}"
+          puts "parent_path: #{parent_path.inspect}"
+          if !text.empty?
+            puts "text"
+            indent { text.each { |txt| puts txt } }
+          end
+          if !opts.empty?
+            puts "opts"
+            indent { opts.each(&:dump) }
+          end
+          if !cmds.empty?
+            puts "cmds (#{cmds.size})"
+            indent { cmds.each(&:dump) }
+          end
+          if !args.empty?
+            puts "args"
+            indent { args.each { |arg| puts arg } }
+          end
+        }
+      end
+    end
+
+    class Option
+      def dump
+        puts name
+        indent {
+          if !text.empty?
+            puts "text"
+            indent { text.each { |txt| puts txt } }
+          end
+          puts "ident: #{ident.inspect}"
+          puts "names: #{names.join(', ')}"
+          puts "repeatable: #{repeatable?}"
+          puts "argument: #{argument?}"
+          if argument?
+            puts "argument_name: #{argument_name}" if argument_name
+            puts "integer: #{integer?}"
+            puts "float: #{float?}"
+            puts "optional: #{optional?}"
+          end
+        }
+      end
+    end
+  end
+end

data/lib/shellopts/grammar/lexer.rb

@@ -0,0 +1,56 @@
+module ShellOpts
+  module Grammar
+    class Lexer
+      def self.lex(source)
+        lines = source.split("\n").map(&:strip)
+
+        # Skip initial blank lines
+        lines = lines.drop_while { |line| line == "" }
+
+        # Split lines into command, option, argument, or text
+        res = []
+        while line = lines.shift
+          if line =~ SCAN_RE
+            # Collect following comments
+            txts = []
+            while lines.first && lines.first !~ SCAN_RE
+              txts << lines.shift
+            end
+
+            words = line.split(/\s+/)
+            while word = words.shift
+              type = 
+                  case word
+                    when OPTION_RE
+                      "OPT"
+                    when COMMAND_PATH_RE
+                      "CMD"
+                    when ARGUMENT_EXPR_RE
+                      args = [word]
+                      # Scan arguments
+                      while words.first =~ ARGUMENT_EXPR_RE
+                        args << words.shift
+                      end
+                      word = args.join(" ")
+                      "ARG"
+                    when /^[a-z0-9]/
+                      raise CompileError, "Illegal argument: #{word} (should be uppercase)"
+                    else
+                      raise CompileError, "Illegal syntax: #{line}"
+                  end
+              res << [type, word]
+              txts.each { |txt| res << ["TXT", txt] } # Add comments after first command or option
+              txts = []
+            end
+          elsif line =~ /^-|\+/
+            raise CompileError, "Illegal short option name: #{line}"
+          else
+            res << ["TXT", line]
+          end
+        end
+        res
+      end
+    end
+  end
+end
+