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

data/lib/shellopts/args.rb

@@ -48,7 +48,7 @@ module ShellOpts
 
   private
     def inoa(message = nil) 
-      raise ShellOpts::UserError, message || "Illegal number of arguments"
+      raise Error.new(nil), message || "Illegal number of arguments"
     end
   end
 end

data/lib/shellopts/ast/command.rb

@@ -1,41 +1,112 @@
 module ShellOpts
   module Ast
-    class Command < Node
-      # Array of options (Ast::Option). Initially empty but filled out by the
-      # parser
-      attr_reader :options
-
-      # Optional sub-command (Ast::Command). Initially nil but assigned by the
-      # parser
-      attr_accessor :subcommand 
-
-      def initialize(grammar, name)
-        super(grammar, name)
-        @options = []
+    # Note that Command is derived from BasicObject to minimize the number of
+    # reserved names
+    class Command < BasicObject
+      def initialize(grammar)
+        @grammar = grammar
+        @options_list = []
+        @options_hash = {}
         @subcommand = nil
+        @subcommands_hash = {} # have at most one element
+
+        @grammar.opts.each { |opt|
+          if opt.argument?
+            self.instance_eval("def #{opt.ident}() @options_hash[:#{opt.ident}] end")
+          end
+          self.instance_eval("def #{opt.ident}?() @options_hash.key?(:#{opt.ident}) end")
+        }
+
+        @grammar.cmds.each { |cmd|
+          self.instance_eval("def #{cmd.ident}!() @subcommands_hash[:#{cmd.ident}] end")
+        }
       end
 
-      # Array of option or command tuples
-      def values
-        (options + (Array(subcommand || []))).map { |node| node.to_tuple }
+      # Return true if the option was used. Defined in #initialize for each option
+      # def <option>?() end
+      
+      # Return the value of the option. Note that repeated options have their
+      # values aggregated into an array. Defined in #initialize for each option
+      # def <option>() end
+
+      # List of Ast::Option objects in the same order as on the command line
+      def options() @options_list end
+      
+      # Hash from option identifier to option value. Note that repeated options
+      # have their values aggregated into an array
+      def [](ident) @options_hash[ident].argument end
+
+      # Return the sub-command Command object or nil if not present. Defined in
+      # #initialize for each sub-command
+      # def <command>!() end
+
+      # The sub-command identifier or nil if not present
+      def subcommand() @subcommand && Command.grammar(@subcommand).ident end
+
+      # The sub-command Command object or nil if not present
+      def subcommand!() @subcommand end
+
+      # Class-level accessor methods
+      def self.program?(command) command.__send__(:__is_program__) end
+      def self.grammar(command) command.__send__(:__get_grammar__) end
+
+      # Class-level mutating methods
+      def self.add_option(command, option) command.__send__(:__add_option__, option) end
+      def self.add_command(command, subcommand) command.__send__(:__add_command__, subcommand) end
+
+    private
+      # True if this is a Program object
+      def __is_program__() false end
+
+      # Get grammar
+      def __get_grammar__()
+        @grammar
       end
 
-      # :nocov:
-      def dump(&block)
-        super {
-          yield if block_given?
-          puts "options:"
-          indent { options.each { |opt| opt.dump } }
-          print "subcommand:"
-          if subcommand
-            puts
-            indent { subcommand.dump }
-          else
-            puts "nil"
-          end
-        }
+      # Add an option. Only used from the parser
+      def __add_option__(option)
+        @options_list << option
+        if option.grammar.repeatable?        
+          (@options_hash[option.grammar.ident] ||= []) << option.argument
+        else
+          @options_hash[option.grammar.ident] = option.argument
+        end
+      end
+
+      # Set sub-command. Only used from the parser
+      def __add_command__(command)
+        ident = Command.grammar(command).ident
+        @subcommand = command
+        @subcommands_hash[ident] = command
       end
-      # :nocov:
+    end
+
+    class Program < Command
+      def __is_program__() true end
     end
   end
 end
+
+# # TODO: Create class-level methods for access
+# private
+#   # Return class of object. #class is not defined for BasicObjects so this
+#   # method provides an alternative way of getting the class
+#   def self.class_of(object) 
+#     # https://stackoverflow.com/a/18621313/2130986
+#     ::Kernel.instance_method(:class).bind(object).call 
+#   end
+#
+#   # Class method implementation of ObjectStruct#instance_variable_set that is
+#   # not defined in a BasicObject
+#   def self.set_variable(this, var, value)
+#     # https://stackoverflow.com/a/18621313/2130986
+#     ::Kernel.instance_method(:instance_variable_set).bind(this).call(var, value)
+#   end
+#
+#   # Class method implementation of ObjectStruct#instance_variable_get that is
+#   # not defined in a BasicObject
+#   def self.get_variable(this, var)
+#     # https://stackoverflow.com/a/18621313/2130986
+#     ::Kernel.instance_method(:instance_variable_get).bind(this).call(var)
+#   end
+

data/lib/shellopts/ast/dump.rb

@@ -0,0 +1,28 @@
+module ShellOpts
+  module Ast
+    class Command < BasicObject
+      def dump
+        klass = __is_program__ ? "Program" : "Command"
+        ::Kernel.puts "#{@grammar.ident.inspect} (#{klass})"
+        ::Kernel.indent {
+          if !options.empty?
+            options.map(&:dump)
+          end
+          if subcommand
+            subcommand!.dump
+          end
+        }
+      end
+    end
+
+    class Option
+      def dump
+        puts "#{grammar.ident.inspect} (Option)"
+        indent {
+          puts "name: #{name.inspect}"
+          puts "argument: #{argument.inspect}"
+        }
+      end
+    end
+  end
+end

data/lib/shellopts/ast/option.rb

@@ -1,21 +1,15 @@
 module ShellOpts
   module Ast
-    class Option < Node
-      # Optional value. Can be a String, Integer, or Float
-      attr_reader :value
+    class Option
+      attr_reader :grammar
+      attr_reader :name # The actual name used on the command line
+      attr_reader :argument
 
-      def initialize(grammar, name, value)
-        super(grammar, name)
-        @value = value
+      def initialize(grammar, name, argument)
+        @grammar = grammar
+        @name = name
+        @argument = argument
       end
-
-      def values() value end
-
-      # :nocov:
-      def dump
-        super { puts "values: #{values.inspect}" }
-      end
-      # :nocov:
     end
   end
 end

data/lib/shellopts/ast/parser.rb

@@ -0,0 +1,106 @@
+module ShellOpts
+  module Ast
+    # Parse a subcommand
+    class Parser
+      def initialize(grammar, argv)
+        @grammar, @argv = grammar, argv.dup
+        @seen_options = {} # Used to keep track of repeated options
+        @current = nil # Current command
+      end
+
+      def call
+        @current = program = Program.new(@grammar)
+        parse_command(program)
+        cmd = Command.grammar(@current)
+        !cmd.virtual? or error("'%s' command requires a sub-command")
+        [program, Args.new(cmd, @argv)]
+      end
+
+      def self.parse(grammar, argv)
+        self.new(grammar, argv).call
+      end
+
+    private
+      def error(message)
+        grammar = Command.grammar(@current)
+        raise Error.new(grammar), message % grammar.name
+      end
+
+      def parse_command(command)
+        @seen_options = {} # Every new command resets the seen options
+        while arg = @argv.first
+          if arg == "--"
+            @argv.shift
+            break
+          elsif arg.start_with?("-")
+            parse_option(command)
+          elsif cmd = Command.grammar(command).commands[arg]
+            @argv.shift
+            @current = subcommand = Ast::Command.new(cmd)
+            Command.add_command(command, subcommand)
+            parse_command(subcommand)
+            break
+          else
+            break
+          end
+        end
+      end
+
+      def parse_option(command)
+        # Split into name and argument
+        case @argv.first
+          when /^--(.+?)(?:=(.*))?$/
+            name, arg, short = $1, $2, false
+            opt_name = "--#{name}"
+          when /^-(.)(.+)?$/
+            name, arg, short = $1, $2, true
+            opt_name = "-#{name}"
+        end
+        @argv.shift
+
+        option = Command.grammar(command).options[name] or error "Unknown option '#{opt_name}'"
+        !@seen_options.key?(option.ident) || option.repeatable? or error "Duplicate option '#{opt_name}'"
+        @seen_options[option.ident] = true
+
+        # Parse (optional) argument
+        if option.argument?
+          if arg.nil? && !option.optional?
+            if !@argv.empty?
+              arg = @argv.shift
+            else
+              error "Missing argument for option '#{opt_name}'"
+            end
+          end
+          arg &&= parse_option_arg(option, name, arg)
+        elsif arg && short
+          @argv.unshift("-#{arg}")
+          arg = nil
+        elsif !arg.nil?
+          error "No argument allowed for option '#{opt_name}'"
+        end
+        
+        Command.add_option(command, Option.new(option, name, arg))
+      end
+
+      def parse_option_arg(option, name, arg)
+        if option.string?
+          arg
+        elsif arg == ""
+          nil
+        elsif option.integer?
+          arg =~ /^-?\d+$/ or error "Illegal integer in '#{name}' argument: '#{arg}'"
+          arg.to_i
+        else # option.float?
+          # https://stackoverflow.com/a/21891705/2130986
+          arg =~ /^[+-]?(?:0|[1-9]\d*)(?:\.(?:\d*[1-9]|0))?$/ or
+              error "Illegal float in '#{name}' argument: '#{arg}'"
+          arg.to_f
+        end
+      end
+    end
+  end
+end
+
+
+
+

data/lib/shellopts/constants.rb

@@ -0,0 +1,88 @@
+
+module ShellOpts
+  # FIXME: An option group is -abcd, an option list is a,b,c,d
+  module Constants
+    # Short and long option names
+    SHORT_OPTION_NAME_SUB_RE = /[a-zA-Z0-9]/
+    LONG_OPTION_NAME_SUB_RE = /[a-z](?:[\w-]*\w)/
+    OPTION_NAME_SUB_RE = /#{SHORT_OPTION_NAME_SUB_RE}|#{LONG_OPTION_NAME_SUB_RE}/
+
+    # Initial option in a group
+    INITIAL_SHORT_OPTION_SUB_RE = /[-+]#{SHORT_OPTION_NAME_SUB_RE}/
+    INITIAL_LONG_OPTION_SUB_RE = /(?:--|\+\+)#{LONG_OPTION_NAME_SUB_RE}/
+    INITIAL_OPTION_SUB_RE = /#{INITIAL_SHORT_OPTION_SUB_RE}|#{INITIAL_LONG_OPTION_SUB_RE}/
+
+    # A list of short and long options
+    OPTION_GROUP_SUB_RE = /#{INITIAL_OPTION_SUB_RE}(?:,#{OPTION_NAME_SUB_RE})*/
+
+    # Option argument
+    OPTION_ARG_SUB_RE = /[A-Z](?:[A-Z0-9_-]*[A-Z0-9])?/
+    
+    # Matches option flags and argument. It defines the following captures
+    #
+    #   $1 - Argument flag ('=')
+    #   $2 - Type flag ('#' or '$')
+    #   $3 - Argument name
+    #   $4 - Optional flag ('?')
+    #
+    OPTION_FLAGS_SUB_RE = /(=)(#|\$)?(#{OPTION_ARG_SUB_RE})?(\?)?/
+
+    # Matches a declaration of an option. The RE defines the following captures:
+    #
+    #   $1 - Option group
+    #   $2 - Argument flag ('=')
+    #   $3 - Type flag ('#' or '$')
+    #   $4 - Argument name
+    #   $5 - Optional flag ('?')
+    #
+    OPTION_SUB_RE = /(#{OPTION_GROUP_SUB_RE})#{OPTION_FLAGS_SUB_RE}?/
+    
+    # Command and command paths
+    COMMAND_IDENT_SUB_RE = /[a-z](?:[a-z0-9_-]*[a-z0-9])?/
+    COMMAND_SUB_RE = /#{COMMAND_IDENT_SUB_RE}!/
+    COMMAND_PATH_SUB_RE = /#{COMMAND_IDENT_SUB_RE}(?:\.#{COMMAND_IDENT_SUB_RE})*!/
+
+    # Command argument
+    ARGUMENT_SUB_RE = /[A-Z][A-Z0-9_-]*[A-Z0-9](?:\.\.\.)?/
+    ARGUMENT_EXPR_SUB_RE = /\[?#{ARGUMENT_SUB_RE}(?:#{ARGUMENT_SUB_RE}|[\[\]\|\s])*/
+
+    # Matches a line starting with a command or an option
+    SCAN_RE = /^(?:#{COMMAND_PATH_SUB_RE}|#{OPTION_SUB_RE})(?:\s+.*)?$/
+
+
+    # Create anchored REs for all SUB_REs
+    self.constants.each { |c|
+      next if c.to_s !~ /_SUB_RE$/
+      sub_re = self.const_get(c)
+      next if !sub_re.is_a?(Regexp)
+      re = /^#{sub_re}$/
+      name = c.to_s.sub(/_SUB_RE$/, "_RE")
+      self.const_set(name, re)
+    }
+
+    # Method names reserved by the BasicObject class
+    BASIC_OBJECT_RESERVED_WORDS = %w(
+      ! != == __id__ __send__ equal? instance_eval instance_exec method_missing
+      singleton_method_added singleton_method_removed singleton_method_undefined)
+
+    # Method names reserved by the Ast::Command class
+    AST_COMMAND_RESERVED_WORDS = %w(
+      initialize options subcommand __is_program__ __get_grammar__
+      __add_option__ __add_command__)
+
+    # Reserved option names
+    OPTION_RESERVED_WORDS = 
+        (BASIC_OBJECT_RESERVED_WORDS + AST_COMMAND_RESERVED_WORDS).grep(OPTION_NAME_RE)
+
+    # Reserved command names
+    COMMAND_RESERVED_WORDS = %w(subcommand)
+  end
+
+  include Constants
+end
+
+
+
+
+
+

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
+