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

data/lib/shellopts/args.rb

@@ -2,21 +2,23 @@
 module ShellOpts
   # Specialization of Array for arguments lists. Args extends Array with a
   # #extract and an #expect method to extract elements from the array. The
-  # methods call #error() in response to errors
+  # methods raise a ShellOpts::UserError exception in case of errors
   class Args < Array
     def initialize(shellopts, *args)
       @shellopts = shellopts
       super(*args)
     end
 
-    # Remove and return elements from beginning of the array. If
-    # +count_or_range+ is a number, that number of elements will be returned.
-    # If the count is one, a simple value is returned instead of an array.  If
-    # the count is negative, the elements will be removed from the end of the
-    # array. If +count_or_range+ is a range, the number of elements returned
-    # will be in that range. The range can't contain negative numbers #expect
-    # calls #error() if there's is not enough elements in the array to satisfy
-    # the request
+    # Remove and return elements from beginning of the array
+    #
+    # If +count_or_range+ is a number, that number of elements will be
+    # returned.  If the count is one, a simple value is returned instead of an
+    # array.  If the count is negative, the elements will be removed from the
+    # end of the array. If +count_or_range+ is a range, the number of elements
+    # returned will be in that range. The range can't contain negative numbers 
+    #
+    # #extract raise a ShellOpts::UserError exception if there's is not enough
+    # elements in the array to satisfy the request
     def extract(count_or_range, message = nil) 
       if count_or_range.is_a?(Range)
         range = count_or_range
@@ -24,17 +26,21 @@ module ShellOpts
         n_extract = [self.size, range.max].min
         n_extend = range.max > self.size ? range.max - self.size : 0
         r = self.shift(n_extract) + Array.new(n_extend)
+        range.max <= 1 ? r.first : r
       else
         count = count_or_range
         self.size >= count.abs or inoa(message)
         start = count >= 0 ? 0 : size + count
         r = slice!(start, count.abs)
-        r.size == 0 ? nil : (r.size == 1 ? r.first : r)
+        r.size <= 0 ? nil : (r.size == 1 ? r.first : r)
       end
     end
 
-    # As extract except it doesn't allow negative counts and that the array is
+    # As #extract except it doesn't allow negative counts and that the array is
     # expect to be emptied by the operation
+    #
+    # #expect raise a ShellOpts::UserError exception if the array is not emptied 
+    # by the operation
     def expect(count_or_range, message = nil)
       count_or_range === self.size or inoa(message)
       extract(count_or_range) # Can't fail
@@ -42,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
+
+
+
+
+
+