shellopts 2.0.0.pre.13 → 2.0.0.pre.14

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
+

data/lib/shellopts/grammar/option.rb

@@ -1,66 +1,55 @@
 module ShellOpts
   module Grammar
-    # Models an Option
-    #
-    # Sets Node#key to the first long option name if present or else the first short option
-    class Option < Node
-      # List of short names (incl. '-')
-      attr_reader :short_names
-
-      # List of long names (incl. '--')
-      attr_reader :long_names
-
-      # Name of the key attribute (eg. if key is :all then key_name is '--all'
-      attr_reader :key_name
-
-      # List of flags (Symbol)
-      def flags() @flags.keys end
-
-      # Informal name of argument (eg. 'FILE'). nil if not present
-      attr_reader :label
-
-      # Initialize an option. Short and long names are arrays of the short/long
-      # option names (incl. the '-'/'--' prefix). It is assumed that at least
-      # one name is given. Flags is a list of symbolic flags. Allowed flags are
-      # :repeated, :argument, :optional, :integer, and :float. Note that
-      # there's no :string flag, it's status is inferred. label is the optional
-      # informal name of the option argument (eg. 'FILE') or nil if not present
-      def initialize(short_names, long_names, flags, label = nil)
-        @key_name = long_names.first || short_names.first
-        name = @key_name.sub(/^-+/, "")
-        super(name.to_sym, name)
-        @short_names, @long_names = short_names, long_names
-        @flags = flags.map { |flag| [flag, true] }.to_h
-        @label = label
-      end
-
-      # Array of option names with short names first and then the long names
-      def names() @short_names + @long_names end
-
-      # Array of names and the key
-      def identifiers() names + [key] end
-
-      # Return true if +ident+ is equal to any name or to key
-      def match?(ident) names.include?(ident) || ident == key end
-
-      # Flag query methods. Returns true if the flag is present and otherwise nil
-      def repeated?() @flags[:repeated] || false end
-      def argument?() @flags[:argument] || false end
-      def optional?() argument? && @flags[:optional] || false end
-      def string?() argument? && !integer? && !float? end
-      def integer?() argument? && @flags[:integer] || false end
-      def float?() argument? && @flags[:float] || false end
-
-      # :nocov:
-      def dump
-        super {
-          puts "short_names: #{short_names.inspect}"
-          puts "long_names: #{long_names.inspect}"
-          puts "flags: #{flags.inspect}"
-          puts "label: #{label.inspect}"
-        }
+    class Option
+      # Symbolic identifier. This is the name of the option with dashes ('-')
+      # replaced with underscores ('_')
+      attr_reader :ident
+
+      # Name of option. This is the name of the first long option or the name
+      # of the first short option if there is no long option name. It is used
+      # to compute #ident
+      attr_reader :name
+
+      # Long name of option or nil if not present
+      attr_reader :longname
+
+      # Short name of option or nil if not present
+      attr_reader :shortname
+
+      # List of all names
+      attr_reader :names
+
+      # Name of argument or nil if not present
+      attr_reader :argument_name
+
+      # Comment
+      attr_reader :text
+
+      def repeatable?() @repeatable end
+      def argument?() @argument end
+      def integer?() @integer end
+      def float?() @float end
+      def string?() !@integer && !@float end
+      def optional?() @optional end
+
+      def initialize(names, repeatable: nil, argument: nil, integer: nil, float: nil, optional: nil)
+        @names = names.dup
+        @longname = @names.find { |name| name.length > 1 } 
+        @shortname = @names.find { |name| name.length == 1 }
+        @name = @longname || @shortname
+        @ident = @name.gsub("-", "_").to_sym
+        @repeatable = repeatable || false
+        if argument
+          @argument = true
+          @argument_name = argument if argument.is_a?(String)
+        else
+          @argument = false
+        end
+        @integer = integer || false
+        @float = float || false
+        @optional = optional || false
+        @text = []
       end
-      # :nocov:
     end
   end
 end