docopt_ng 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ee12e3238546070b62a14408b24689dda48af1067ed5d139f3795a5cee2f9b9
+  data.tar.gz: 49082568fa660901f429539174e0826456d02d4efda581c09a1ecd1d53dd6276
+SHA512:
+  metadata.gz: f78d00cfe0a68f4ce42f5c224ceb631bfcfe728a741babd65242443efc8f754a763c2caff34fedeed83ee4902813752b2e9a297da9019581182505f5fe555420
+  data.tar.gz: 269e933d636bc8b05ed19a51b0eef742611b6413205c64b2d156458d290d3cbe6f15c78b6ea3807582a60aec8a3681dd829a6ae0893f2e28f693106c466336ed

data/README.md

@@ -0,0 +1,147 @@
+# Docopt – command line option parser, that will make you smile
+
+---
+
+This is a detached fork of the original [docopt.rb](https://github.com/docopt/docopt.rb).
+
+- For a drop-in replacement, simply `require 'docopt_ng/docopt'`
+- Otherwise, use `require 'docopt_ng'` and `DocoptNG` instead of `Docopt`.
+
+---
+
+This is the ruby port of [`docopt`](https://github.com/docopt/docopt),
+the awesome option parser written originally in python.
+
+Isn't it awesome how `optparse` and `argparse` generate help messages
+based on your code?!
+
+*Hell no!*  You know what's awesome?  It's when the option parser *is* generated
+based on the beautiful help message that you write yourself!  This way
+you don't need to write this stupid repeatable parser-code, and instead can
+write only the help message--*the way you want it*.
+
+`docopt` helps you create most beautiful command-line interfaces *easily*:
+
+```ruby
+require "docopt_ng/docopt"
+
+doc = <<DOCOPT
+Naval Fate.
+
+Usage:
+  #{__FILE__} ship new <name>...
+  #{__FILE__} ship <name> move <x> <y> [--speed=<kn>]
+  #{__FILE__} ship shoot <x> <y>
+  #{__FILE__} mine (set|remove) <x> <y> [--moored|--drifting]
+  #{__FILE__} -h | --help
+  #{__FILE__} --version
+
+Options:
+  -h --help     Show this screen.
+  --version     Show version.
+  --speed=<kn>  Speed in knots [default: 10].
+  --moored      Moored (anchored) mine.
+  --drifting    Drifting mine.
+
+DOCOPT
+
+begin
+  pp Docopt::docopt(doc)
+rescue Docopt::Exit => e
+  puts e.message
+end
+```
+
+Beat that! The option parser is generated based on the docstring above that is
+passed to `docopt` function.  `docopt` parses the usage pattern
+(`Usage: ...`) and option descriptions (lines starting with dash "`-`") and
+ensures that the program invocation matches the usage pattern; it parses
+options, arguments and commands based on that. The basic idea is that
+*a good help message has all necessary information in it to make a parser*.
+
+## Installation
+
+
+```shell
+$ gem install docopt_ng
+```
+
+
+## API
+
+`Docopt` takes 1 required and 1 optional argument:
+
+- `doc` should be a string that
+  describes **options** in a human-readable format, that will be parsed to create
+  the option parser.  The simple rules of how to write such a docstring
+  (in order to generate option parser from it successfully) are given in the next
+  section. Here is a quick example of such a string:
+
+        Usage: your_program.rb [options]
+
+        -h --help     Show this.
+        -v --verbose  Print more text.
+        --quiet       Print less text.
+        -o FILE       Specify output file [default: ./test.txt].
+
+  The optional second argument contains a hash of additional data to influence
+  docopt. The following keys are supported: 
+
+- `help`, by default `true`, specifies whether the parser should automatically
+  print the usage-message (supplied as `doc`) in case `-h` or `--help` options
+  are encountered. After showing the usage-message, the program will terminate.
+  If you want to handle `-h` or `--help` options manually (as all other options),
+  set `help=false`.
+
+- `version`, by default `nil`, is an optional argument that specifies the
+  version of your program. If supplied, then, if the parser encounters
+  `--version` option, it will print the supplied version and terminate.
+  `version` could be any printable object, but most likely a string,
+  e.g. `'2.1.0rc1'`.
+
+Note, when `docopt` is set to automatically handle `-h`, `--help` and
+`--version` options, you still need to mention them in the options description
+(`doc`) for your users to know about them.
+
+The **return** value is just a hash with options, arguments and commands,
+with keys spelled exactly like in a help message
+(long versions of options are given priority). For example, if you invoke
+the top example as:
+
+```
+$ naval_fate.rb ship Guardian move 100 150 --speed=15
+```
+
+the return hash will be::
+
+```ruby
+{
+  "ship" => true,
+  "new" => false,
+  "<name>" => ["Guardian"],
+  "move" => true,
+  "<x>" => "100",
+  "<y>" => "150",
+  "--speed" => "15",
+  "shoot" => false,
+  "mine" => false,
+  "set" => false,
+  "remove" => false,
+  "--moored" => false,
+  "--drifting" => false,
+  "--help" => false,
+  "--version" => false
+}
+```
+
+## Help message format
+
+This port of docopt follows the docopt help message format.
+You can find more details at
+[official docopt git repo](https://github.com/docopt/docopt#help-message-format)
+
+
+## Examples
+
+The [examples directory](examples) contains several examples which cover most
+aspects of the docopt functionality. 

data/lib/docopt_ng/any_options.rb

@@ -0,0 +1,6 @@
+require 'docopt_ng/optional'
+
+module DocoptNG
+  class AnyOptions < Optional
+  end
+end

data/lib/docopt_ng/argument.rb

@@ -0,0 +1,23 @@
+require 'docopt_ng/child_pattern'
+
+module DocoptNG
+  class Argument < ChildPattern
+    def single_match(left)
+      left.each_with_index do |p, n|
+        if p.instance_of?(Argument)
+          return [n, Argument.new(name, p.value)]
+        end
+      end
+
+      [nil, nil]
+    end
+
+    # TODO: This does not seem to be used, and can be the solution to having
+    #       default values for arguments
+    def self.parse(class_, source)
+      name = /(<\S*?>)/.match(source)[0]
+      value = /\[default: (.*)\]/i.match(source)
+      class_.new(name, (value ? value[0] : nil))
+    end
+  end
+end

data/lib/docopt_ng/child_pattern.rb

@@ -0,0 +1,51 @@
+require 'docopt_ng/pattern'
+
+module DocoptNG
+  class ChildPattern < Pattern
+    attr_accessor :name, :value
+
+    def initialize(name, value = nil)
+      @name = name
+      @value = value
+    end
+
+    def inspect
+      "#{self.class.name}(#{name}, #{value})"
+    end
+
+    def flat(*types)
+      if types.empty? || types.include?(self.class)
+        [self]
+      else
+        []
+      end
+    end
+
+    def match(left, collected = nil)
+      collected ||= []
+      pos, match = single_match(left)
+
+      return [false, left, collected] if match.nil?
+
+      left_ = left.dup
+      left_.slice!(pos)
+
+      same_name = collected.select { |a| a.name == name }
+      if @value.is_a?(Array) || @value.is_a?(Integer)
+        increment = if @value.is_a? Integer
+          1
+        else
+          match.value.is_a?(String) ? [match.value] : match.value
+        end
+        if same_name.count.zero?
+          match.value = increment
+          return [true, left_, collected + [match]]
+        end
+        same_name[0].value += increment
+        return [true, left_, collected]
+      end
+
+      [true, left_, collected + [match]]
+    end
+  end
+end

data/lib/docopt_ng/command.rb

@@ -0,0 +1,21 @@
+require 'docopt_ng/argument'
+
+module DocoptNG
+  class Command < Argument
+    def initialize(name, value = false)
+      @name = name
+      @value = value
+    end
+
+    def single_match(left)
+      left.each_with_index do |p, n|
+        next unless p.instance_of?(Argument)
+        return n, Command.new(name, true) if p.value == name
+
+        break
+      end
+
+      [nil, nil]
+    end
+  end
+end

data/lib/docopt_ng/docopt.rb

@@ -0,0 +1,2 @@
+require 'docopt_ng'
+Docopt = DocoptNG

data/lib/docopt_ng/either.rb

@@ -0,0 +1,24 @@
+require 'docopt_ng/parent_pattern'
+
+module DocoptNG
+  class Either < ParentPattern
+    def match(left, collected = nil)
+      collected ||= []
+      outcomes = []
+      children.each do |p|
+        matched, = found = p.match(left, collected)
+        if matched
+          outcomes << found
+        end
+      end
+
+      if outcomes.count.positive?
+        return outcomes.min_by do |outcome|
+          outcome[1].nil? ? 0 : outcome[1].count
+        end
+      end
+
+      [false, left, collected]
+    end
+  end
+end

data/lib/docopt_ng/exceptions.rb

@@ -0,0 +1,18 @@
+module DocoptNG
+  class DocoptLanguageError < SyntaxError
+  end
+
+  class Exit < RuntimeError
+    class << self
+      attr_reader :usage
+
+      def set_usage(text = nil)
+        @usage = text || ''
+      end
+    end
+
+    def initialize(message = '')
+      super "#{message}\n#{self.class.usage}".strip
+    end
+  end
+end

data/lib/docopt_ng/one_or_more.rb

@@ -0,0 +1,30 @@
+require 'docopt_ng/parent_pattern'
+
+module DocoptNG
+  class OneOrMore < ParentPattern
+    def match(left, collected = nil)
+      raise RuntimeError if children.count != 1
+
+      collected ||= []
+      l = left
+      c = collected
+      l_ = nil
+      matched = true
+      times = 0
+      while matched
+        # could it be that something didn't match but changed l or c?
+        matched, l, c = children[0].match(l, c)
+        times += (matched ? 1 : 0)
+        break if l_ == l
+
+        l_ = l
+      end
+
+      if times.positive?
+        [true, l, c]
+      else
+        [false, left, collected]
+      end
+    end
+  end
+end

data/lib/docopt_ng/option.rb

@@ -0,0 +1,63 @@
+require 'docopt_ng/child_pattern'
+
+module DocoptNG
+  class Option < ChildPattern
+    attr_reader :short, :long
+    attr_accessor :argcount
+
+    def initialize(short = nil, long = nil, argcount = 0, value = false)
+      raise RuntimeError unless [0, 1].include? argcount
+
+      @short = short
+      @long = long
+      @argcount = argcount
+      @value = value
+
+      @value = if (value == false) && argcount.positive?
+        nil
+      else
+        value
+      end
+    end
+
+    def self.parse(option_description)
+      short = nil
+      long = nil
+      argcount = 0
+      value = false
+      options, _, description = option_description.strip.partition('  ')
+
+      options = options.tr(',', ' ').tr('=', ' ')
+
+      options.split.each do |s|
+        if s.start_with?('--')
+          long = s
+        elsif s.start_with?('-')
+          short = s
+        else
+          argcount = 1
+        end
+      end
+      if argcount.positive?
+        matched = description.scan(/\[default: (.*)\]/i)
+        value = matched[0][0] if matched.count.positive?
+      end
+      new(short, long, argcount, value)
+    end
+
+    def single_match(left)
+      left.each_with_index do |p, n|
+        return [n, p] if name == p.name
+      end
+      [nil, nil]
+    end
+
+    def name
+      long || short
+    end
+
+    def inspect
+      "Option(#{short}, #{long}, #{argcount}, #{value})"
+    end
+  end
+end

data/lib/docopt_ng/optional.rb

@@ -0,0 +1,13 @@
+require 'docopt_ng/parent_pattern'
+
+module DocoptNG
+  class Optional < ParentPattern
+    def match(left, collected = nil)
+      collected ||= []
+      children.each do |p|
+        _, left, collected = p.match(left, collected)
+      end
+      [true, left, collected]
+    end
+  end
+end

data/lib/docopt_ng/parent_pattern.rb

@@ -0,0 +1,24 @@
+require 'docopt_ng/pattern'
+
+module DocoptNG
+  class ParentPattern < Pattern
+    attr_accessor :children
+
+    def initialize(*children)
+      @children = children
+    end
+
+    def inspect
+      childstr = children.map(&:inspect)
+      "#{self.class.name}(#{childstr.join(', ')})"
+    end
+
+    def flat(*types)
+      if types.include?(self.class)
+        [self]
+      else
+        children.map { |c| c.flat(*types) }.flatten
+      end
+    end
+  end
+end

data/lib/docopt_ng/pattern.rb

@@ -0,0 +1,104 @@
+module DocoptNG
+  class Pattern
+    attr_accessor :children
+
+    def ==(other)
+      inspect == other.inspect
+    end
+
+    def to_str
+      inspect
+    end
+
+    def dump
+      puts ::Docopt.dump_patterns(self)
+    end
+
+    def fix
+      fix_identities
+      fix_repeating_arguments
+      self
+    end
+
+    def fix_identities(uniq = nil)
+      unless instance_variable_defined?(:@children)
+        return self
+      end
+
+      uniq ||= flat.uniq
+
+      @children.each_with_index do |c, i|
+        if c.instance_variable_defined?(:@children)
+          c.fix_identities(uniq)
+        else
+          unless uniq.include?(c)
+            raise RuntimeError
+          end
+
+          @children[i] = uniq[uniq.index(c)]
+        end
+      end
+    end
+
+    def fix_repeating_arguments
+      either.children.map(&:children).each do |case_|
+        case_.select { |c| case_.count(c) > 1 }.each do |e|
+          if e.instance_of?(Argument) || (e.instance_of?(Option) && e.argcount.positive?)
+            if e.value.nil?
+              e.value = []
+            elsif e.value.class != Array
+              e.value = e.value.split
+            end
+          end
+          if e.instance_of?(Command) || (e.instance_of?(Option) && e.argcount.zero?)
+            e.value = 0
+          end
+        end
+      end
+
+      self
+    end
+
+    def either
+      ret = []
+      groups = [[self]]
+      while groups.count.positive?
+        children = groups.shift
+        types = children.map(&:class)
+
+        if types.include?(Either)
+          either = children.find { |child| child.instance_of?(Either) }
+          children.slice!(children.index(either))
+          either.children.each do |c|
+            groups << ([c] + children)
+          end
+        elsif types.include?(Required)
+          required = children.find { |child| child.instance_of?(Required) }
+          children.slice!(children.index(required))
+          groups << (required.children + children)
+
+        elsif types.include?(Optional)
+          optional = children.find { |child| child.instance_of?(Optional) }
+          children.slice!(children.index(optional))
+          groups << (optional.children + children)
+
+        elsif types.include?(AnyOptions)
+          anyoptions = children.find { |child| child.instance_of?(AnyOptions) }
+          children.slice!(children.index(anyoptions))
+          groups << (anyoptions.children + children)
+
+        elsif types.include?(OneOrMore)
+          oneormore = children.find { |child| child.instance_of?(OneOrMore) }
+          children.slice!(children.index(oneormore))
+          groups << ((oneormore.children * 2) + children)
+
+        else
+          ret << children
+        end
+      end
+
+      args = ret.map { |e| Required.new(*e) }
+      Either.new(*args)
+    end
+  end
+end

data/lib/docopt_ng/required.rb

@@ -0,0 +1,17 @@
+require 'docopt_ng/parent_pattern'
+
+module DocoptNG
+  class Required < ParentPattern
+    def match(left, collected = nil)
+      collected ||= []
+      l = left
+      c = collected
+
+      children.each do |p|
+        matched, l, c = p.match(l, c)
+        return [false, left, collected] unless matched
+      end
+      [true, l, c]
+    end
+  end
+end

data/lib/docopt_ng/token_stream.rb

@@ -0,0 +1,23 @@
+module DocoptNG
+  class TokenStream < Array
+    attr_reader :error
+
+    def initialize(source, error)
+      if !source
+        source = []
+      elsif source.class != ::Array
+        source = source.split
+      end
+      super(source)
+      @error = error
+    end
+
+    def move
+      shift
+    end
+
+    def current
+      self[0]
+    end
+  end
+end

data/lib/docopt_ng/version.rb

@@ -0,0 +1,3 @@
+module DocoptNG
+  VERSION = '0.7.0'
+end

data/lib/docopt_ng.rb

@@ -0,0 +1,290 @@
+require 'docopt_ng/exceptions'
+require 'docopt_ng/pattern'
+require 'docopt_ng/child_pattern'
+require 'docopt_ng/parent_pattern'
+require 'docopt_ng/argument'
+require 'docopt_ng/command'
+require 'docopt_ng/option'
+require 'docopt_ng/required'
+require 'docopt_ng/optional'
+require 'docopt_ng/any_options'
+require 'docopt_ng/one_or_more'
+require 'docopt_ng/either'
+require 'docopt_ng/token_stream'
+
+module DocoptNG
+module_function
+
+  def parse_long(tokens, options)
+    long, eq, value = tokens.move.partition('=')
+
+    raise RuntimeError unless long.start_with?('--')
+
+    value = nil if (eq == value) && (eq == '')
+    similar = options.select { |o| o.long and o.long == long }
+
+    if (tokens.error == Exit) && (similar == [])
+      similar = options.select { |o| o.long and o.long.start_with?(long) }
+    end
+
+    if similar.count > 1
+      ostr = similar.map(&:long).join(', ')
+      raise tokens.error, "#{long} is not a unique prefix: #{ostr}?"
+    elsif similar.count < 1
+      argcount = (eq == '=' ? 1 : 0)
+      o = Option.new(nil, long, argcount)
+      options << o
+      if tokens.error == Exit
+        o = Option.new(nil, long, argcount, (argcount == 1 ? value : true))
+      end
+    else
+      s0 = similar[0]
+      o = Option.new(s0.short, s0.long, s0.argcount, s0.value)
+      if o.argcount.zero?
+        unless value.nil?
+          raise tokens.error, "#{o.long} must not have an argument"
+        end
+      elsif value.nil?
+        if tokens.current.nil?
+          raise tokens.error, "#{o.long} requires argument"
+        end
+
+        value = tokens.move
+      end
+      if tokens.error == Exit
+        o.value = (value.nil? ? true : value)
+      end
+    end
+    [o]
+  end
+
+  def parse_shorts(tokens, options)
+    token = tokens.move
+    unless token.start_with?('-') && !token.start_with?('--')
+      raise RuntimeError
+    end
+
+    left = token[1..]
+    parsed = []
+    while left != ''
+      short = "-#{left[0]}"
+      left = left[1..]
+      similar = options.select { |o| o.short == short }
+      if similar.count > 1
+        raise tokens.error, "#{short} is specified ambiguously #{similar.count} times"
+      elsif similar.count < 1
+        o = Option.new(short, nil, 0)
+        options << o
+        if tokens.error == Exit
+          o = Option.new(short, nil, 0, true)
+        end
+      else
+        s0 = similar[0]
+        o = Option.new(short, s0.long, s0.argcount, s0.value)
+        value = nil
+        if o.argcount != 0
+          if left == ''
+            if tokens.current.nil?
+              raise tokens.error, "#{short} requires argument"
+            end
+
+            value = tokens.move
+          else
+            value = left
+            left = ''
+          end
+        end
+        if tokens.error == Exit
+          o.value = (value.nil? ? true : value)
+        end
+      end
+
+      parsed << o
+    end
+    parsed
+  end
+
+  def parse_pattern(source, options)
+    tokens = TokenStream.new(source.gsub(/([\[\]()|]|\.\.\.)/, ' \1 '), DocoptLanguageError)
+
+    result = parse_expr(tokens, options)
+    unless tokens.current.nil?
+      raise tokens.error, "unexpected ending: #{tokens.join(' ')}"
+    end
+
+    Required.new(*result)
+  end
+
+  def parse_expr(tokens, options)
+    seq = parse_seq(tokens, options)
+    if tokens.current != '|'
+      return seq
+    end
+
+    result = seq.count > 1 ? [Required.new(*seq)] : seq
+
+    while tokens.current == '|'
+      tokens.move
+      seq = parse_seq(tokens, options)
+      result += seq.count > 1 ? [Required.new(*seq)] : seq
+    end
+    result.count > 1 ? [Either.new(*result)] : result
+  end
+
+  def parse_seq(tokens, options)
+    result = []
+    stop = [nil, ']', ')', '|']
+    until stop.include?(tokens.current)
+      atom = parse_atom(tokens, options)
+      if tokens.current == '...'
+        atom = [OneOrMore.new(*atom)]
+        tokens.move
+      end
+      result += atom
+    end
+    result
+  end
+
+  def parse_atom(tokens, options)
+    token = tokens.current
+
+    if ['(', '['].include? token
+      tokens.move
+      if token == '('
+        matching = ')'
+        pattern = Required
+      else
+        matching = ']'
+        pattern = Optional
+      end
+
+      result = pattern.new(*parse_expr(tokens, options))
+
+      if tokens.move != matching
+        raise tokens.error, "unmatched '#{token}'"
+      end
+
+      [result]
+    elsif token == 'options'
+      tokens.move
+      [AnyOptions.new]
+    elsif token.start_with?('--') && (token != '--')
+      parse_long(tokens, options)
+    elsif token.start_with?('-') && !['-', '--'].include?(token)
+      parse_shorts(tokens, options)
+    elsif (token.start_with?('<') && token.end_with?('>')) || (token.upcase == token && token.match(/[A-Z]/))
+      [Argument.new(tokens.move)]
+    else
+      [Command.new(tokens.move)]
+    end
+  end
+
+  def parse_argv(tokens, options, options_first = false)
+    parsed = []
+    until tokens.current.nil?
+      if tokens.current == '--' || options_first
+        return parsed + tokens.map { |v| Argument.new(nil, v) }
+      elsif tokens.current.start_with?('--')
+        parsed += parse_long(tokens, options)
+      elsif tokens.current.start_with?('-') && (tokens.current != '-')
+        parsed += parse_shorts(tokens, options)
+      else
+        parsed << Argument.new(nil, tokens.move)
+      end
+    end
+    parsed
+  end
+
+  def parse_defaults(doc)
+    split = doc.split(/^ *(<\S+?>|-\S+?)/).drop(1)
+    split = split.each_slice(2).select { |pair| pair.count == 2 }.map { |s1, s2| s1 + s2 }
+    split.select { |s| s.start_with?('-') }.map { |s| Option.parse(s) }
+  end
+
+  def printable_usage(doc)
+    usage_split = doc.split(/([Uu][Ss][Aa][Gg][Ee]:)/)
+    if usage_split.count < 3
+      raise DocoptLanguageError, '"usage:" (case-insensitive) not found.'
+    end
+    if usage_split.count > 3
+      raise DocoptLanguageError, 'More than one "usage:" (case-insensitive).'
+    end
+
+    usage_split.drop(1).join.split(/\n\s*\n/)[0].strip
+  end
+
+  def formal_usage(printable_usage)
+    pu = printable_usage[/usage:(.*)/mi, 1]
+
+    lines = pu.lines(chomp: true).reject(&:empty?).map do |a|
+      "( #{a.split.drop(1).join(' ')} )"
+    end
+
+    lines.join ' | '
+  end
+
+  def dump_patterns(pattern, indent = 0)
+    ws = ' ' * 4 * indent
+    out = ''
+    if pattern.instance_of?(Array)
+      if pattern.count.positive?
+        out << ws << "[\n"
+        pattern.each do |p|
+          out << dump_patterns(p, indent + 1).rstrip << "\n"
+        end
+        out << ws << "]\n"
+      else
+        out << ws << "[]\n"
+      end
+
+    elsif pattern.class.ancestors.include?(ParentPattern)
+      out << ws << pattern.class.name << "(\n"
+      pattern.children.each do |p|
+        out << dump_patterns(p, indent + 1).rstrip << "\n"
+      end
+      out << ws << ")\n"
+
+    else
+      out << ws << pattern.inspect
+    end
+    out
+  end
+
+  def extras(help, version, options, doc)
+    help_flags = ['-h', '--help']
+    if help && options.any? { |o| help_flags.include?(o.name) && o.value }
+      Exit.set_usage(nil)
+      raise Exit, doc.strip
+    end
+    return unless version && options.any? { |o| o.name == '--version' && o.value }
+
+    Exit.set_usage(nil)
+    raise Exit, version
+  end
+
+  def docopt(doc, params = {})
+    default = { version: nil, argv: nil, help: true, options_first: false }
+    params = default.merge(params)
+    params[:argv] = ARGV unless params[:argv]
+
+    Exit.set_usage(printable_usage(doc))
+    options = parse_defaults(doc)
+    pattern = parse_pattern(formal_usage(Exit.usage), options)
+    argv = parse_argv(TokenStream.new(params[:argv], Exit), options, params[:options_first])
+    pattern_options = pattern.flat(Option).uniq
+    pattern.flat(AnyOptions).each do |ao|
+      doc_options = parse_defaults(doc)
+      ao.children = doc_options.reject { |o| pattern_options.include?(o) }.uniq
+    end
+    extras(params[:help], params[:version], argv, doc)
+
+    matched, left, collected = pattern.fix.match(argv)
+    collected ||= []
+
+    if matched && left.count.zero?
+      return (pattern.flat + collected).to_h { |a| [a.name, a.value] }
+    end
+
+    raise Exit
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: docopt_ng
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Blake Williams
+- Vladimir Keleshev
+- Alex Speller
+- Nima Johari
+- Danny Ben Shitrit
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-02-02 00:00:00.000000000 Z
+dependencies: []
+description: Parse command line arguments from nothing more than a usage message
+email: db@dannyben.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/docopt_ng.rb
+- lib/docopt_ng/any_options.rb
+- lib/docopt_ng/argument.rb
+- lib/docopt_ng/child_pattern.rb
+- lib/docopt_ng/command.rb
+- lib/docopt_ng/docopt.rb
+- lib/docopt_ng/either.rb
+- lib/docopt_ng/exceptions.rb
+- lib/docopt_ng/one_or_more.rb
+- lib/docopt_ng/option.rb
+- lib/docopt_ng/optional.rb
+- lib/docopt_ng/parent_pattern.rb
+- lib/docopt_ng/pattern.rb
+- lib/docopt_ng/required.rb
+- lib/docopt_ng/token_stream.rb
+- lib/docopt_ng/version.rb
+homepage: https://github.com/dannyben/docopt_ng
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/DannyBen/docopt_ng/issues
+  changelog_uri: https://github.com/DannyBen/docopt_ng/blob/master/CHANGELOG.md
+  homepage_uri: https://docopt.org/
+  source_code_uri: https://github.com/DannyBen/docopt_ng
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key: 
+specification_version: 4
+summary: A command line option parser that will make you smile
+test_files: []