rationalist 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8633e4aa82d70469c295b72f899595f3f2213735
+  data.tar.gz: 7f9bb97172fbdfc790f678330c358c8708676e9a
+SHA512:
+  metadata.gz: 3b267e19bb7a9c15b719268dcc10d6fd4b4c29cac268b2769ef965ffb017e94a0048a6f31311e0458c1c42b25331c081e753ff9ca8adf94fd3123f6f2fc6555d
+  data.tar.gz: 938dac9c1c6750e4dedbe63a9a248281871d257ae7c634c002a599f26138ac5602236aab0a66bcf8f13992c030748f33e937d07be2967d95147dbaa0ca7370ae

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,13 @@
+sudo: false
+language: ruby
+
+rvm:
+- 2.2
+- ruby-head
+- jruby-head
+
+cache:
+- bundler
+
+# matrix:
+#   fast_finish: true

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## CHANGELOG
+
+### 2.0.0
+
+* Inital release
+

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'minitest'
+gem 'rake'

data/LICENSE

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+# rationalist [![[version]](https://badge.fury.io/rb/Rationalist.svg)](http://badge.fury.io/rb/rationalist)  [![[travis]](https://travis-ci.org/janlelis/Rationalist.png)](https://travis-ci.org/janlelis/rationalist)
+
+Rationalist parses command-line arguments into a hash. It is strongly influenced
+by substack's [minimist](https://github.com/substack/minimist) nodejs module.
+
+## setup
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'rationalist'
+```
+
+For more info, see the original README below, with all JS replaced with Ruby.
+
+# minimist
+
+parse argument options
+
+This module is the guts of optimist's argument parser without all the
+fanciful decoration.
+
+# example
+
+```ruby
+require 'rationlist'
+argv = Rationalist.parse(ARGV)
+p argv
+```
+
+```
+$ ruby example/parse.rb -a beep -b boop
+{:_=>[], :a=>"beep", :b=>"boop"}
+```
+
+```
+$ ruby example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
+{ :_=>["foo", "bar", "baz"],
+  :x=>3,
+  :y=>4,
+  :n=>5,
+  :a=>true,
+  :b=>true,
+  :c=>true,
+  :beep=>"boop" }
+```
+
+# methods
+
+```ruby
+require 'rationalist'
+```
+
+## argv = Rationalist.parse(args = ARGV, **opts, &unknown_block)
+
+Return an argument object `argv` populated with the array arguments from `args`.
+
+`argv[:_]` contains all the arguments that didn't have an option associated with
+them.
+
+Numeric-looking arguments will be returned as numbers unless `opts[:string]` or
+`opts[:boolean]` is set for that argument name.
+
+Any arguments after `'--'` will not be parsed and will end up in `argv[:_]`.
+
+options can be:
+
+* `opts[:string]` - a string or array of strings argument names to always treat as
+strings
+* `opts[:boolean]` - a boolean, string or array of strings to always treat as
+booleans. if `true` will treat all double hyphenated arguments without equal signs
+as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`)
+* `opts[:alias]` - an object mapping string names to strings or arrays of string
+argument names to use as aliases
+* `opts[:default]` - an object mapping string argument names to default values
+* `opts[:stop_early]` - when true, populate `argv[:_]` with everything after the
+first non-option
+* `opts[:'--']` - when true, populate `argv._` with everything before the `--`
+and `argv[:'--']` with everything after the `--`. Here's an example:
+* `&unknown_block` - a block which is invoked with a command line parameter not
+defined in the `opts` configuration object. If the function returns `false`, the
+unknown option is not added to `argv`.
+
+```ruby
+>> Rationalist.parse('one two three -- four five --six'.split(' '), { '--': true })
+{ :_=>["one", "two", "three"],
+  :"--"=>["four", "five", "--six"] }
+```
+
+Note that with `opts[:'--']` set, parsing for arguments still stops after the
+`--`.
+
+# install
+
+With [rubygems](https://rubygems.org) do:
+
+```
+gem install rationalist
+```
+
+# license
+
+MIT
+
+**rationalist** was written by Jan Lelis and [minimist](https://github.com/substack/minimist) was written by James Halliday.

data/Rakefile

@@ -0,0 +1,44 @@
+# # #
+# Get gemspec info
+
+gemspec_file = Dir['*.gemspec'].first
+gemspec = eval File.read(gemspec_file), binding, gemspec_file
+info = "#{gemspec.name} | #{gemspec.version} | " \
+       "#{gemspec.runtime_dependencies.size} dependencies | " \
+       "#{gemspec.files.size} files"
+
+
+# # #
+# Gem build and install task
+
+desc info
+task :gem do
+  puts info + "\n\n"
+  print "  "; sh "gem build #{gemspec_file}"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+  puts; sh %{gem install --no-document pkg/#{gemspec.name}-#{gemspec.version}.gem}
+end
+
+
+# # #
+# Start an IRB session with the gem loaded
+
+desc "#{gemspec.name} | IRB"
+task :irb do
+  sh "irb -I ./lib -r #{gemspec.name.gsub '-','/'}"
+end
+
+
+# # #
+# Run all specs
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.pattern = "spec/*_spec.rb"
+end
+
+# # #
+# Default task
+
+task default: :test

data/example/parse.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../lib/rationalist'
+argv = Rationalist.parse(ARGV)
+p argv

data/lib/rationalist.rb

@@ -0,0 +1,273 @@
+module Rationalist
+  VERSION = '2.0.0'
+
+  def self.parse(args = ARGV, **options, &unknown_block)
+    Argv.new(args, options, unknown_block).argv
+  end
+
+  class Argv
+    attr_reader :argv
+
+    private
+
+    def initialize(args, options = {}, unknown_block = nil)
+      @args          = args
+      @options       = options
+      @unknown_block = unknown_block
+      @bools         = {}
+      @strings       = {}
+      @all_bools     = false
+      @aliases       = {}
+      @not_flags     = []
+      @argv          = {_: []}
+
+      apply_boolean_option!
+      apply_alias_option!
+      apply_strings_option!
+      apply_defaults_option!
+
+      parse_arguments!
+
+      fill_with_defaults!
+      fill_with_non_flags!
+    end
+
+    def apply_boolean_option!
+      if @options[:boolean] == true
+        @all_bools = true
+      else
+        Array(@options[:boolean] || []).each{ |b| @bools[b.to_sym] = true }
+      end
+    end
+
+    def apply_alias_option!
+      Array(@options[:alias] || {}).each{ |key, value|
+        key = key.to_sym
+        @aliases[key] = value.is_a?(Array) ? value.map(&:to_sym) : value.to_sym
+        Array(@aliases[key]).each{ |x|
+          x = x.to_sym
+          @aliases[x] = [key] + Array(@aliases[key]).select{ |y| x != y }
+        }
+      }
+    end
+
+    def apply_strings_option!
+      Array(@options[:string] || []).each{ |s|
+        s = s.to_sym
+        @strings[s] = true
+        @strings[@aliases[s]] = true if @aliases[s]
+      }
+    end
+
+    def apply_defaults_option!
+      @defaults = @options[:default] || {}
+      @bools.keys.each{ |key|
+        set_argument key, @defaults.has_key?(key) ? @defaults[key] : false
+      }
+    end
+
+    def parse_arguments!
+      if i = @args.index('--')
+        @not_flags, @args = @args[i+1..-1], @args[0..i-1]
+      end
+
+      i = 0
+      while i < @args.length
+        skip_next = false
+
+        case arg = @args[i]
+        when /\A--([^=]+)=(.*)\z/m
+          set_argument($1, $2, arg)
+        when /\A--no-(.+)/
+          set_argument($1, false, arg)
+        when /\A--(.+)/
+          key = $1.to_sym
+          next_arg = @args[i+1]
+          skip_next = handle_dash_dash_argument(
+            key,
+            next_arg,
+            arg,
+            next_arg_is_value?(key, next_arg, /\A-/, false)
+          )
+        when /\A-[^-]+/
+          skip_next = handle_dash_argument(arg.to_sym, @args[i+1])
+        else
+          if handle_unknown_argument(arg.to_s)
+            @argv[:_] += @args[i+1 .. -1]
+            break
+          end
+        end
+
+        i += 1 if skip_next
+        i += 1
+      end
+    end
+
+    def handle_dash_dash_argument(key, next_arg, arg, next_arg_is_value)
+      if next_arg_is_value
+        set_argument(key, next_arg, arg)
+        true
+      elsif next_arg =~ /\A(true|false)\z/
+        set_argument(key, $& == "true", arg)
+        true
+      else
+        set_argument(key, @strings[key] ? '' : true, arg)
+        false
+      end
+    end
+
+    def handle_dash_argument(arg, next_arg)
+      letters = arg[1..-1].split('')
+      broken = false
+      j = -1
+      while j < letters.size - 2
+        j += 1
+        letter = letters[j].to_sym
+        next_letters = arg[j+2 .. -1]
+        if next_letters.to_sym == :-
+          set_argument letter, next_letters, arg
+          next
+        end
+
+        if letter =~ /[A-Za-z]/ && next_letters =~ /-?\d+(\.\d*)?(e-?\d+)?\z/
+          set_argument letter, next_letters, arg
+          broken = true
+          break
+        end
+
+        next_letter = letters[j+1]
+        if next_letter && next_letter =~ /\W/
+          set_argument letter, arg[j+2 .. -1], arg
+          broken = true
+          break
+        else
+          set_argument letter, @strings[letter] ? '' : true, arg
+        end
+      end
+
+      key = arg[-1].to_sym
+      if !broken && key != :-
+        return handle_dash_dash_argument(
+          key,
+          next_arg,
+          arg,
+          next_arg_is_value?(key, next_arg, /\A(-|--)[^-]/, true)
+        )
+      end
+
+      false
+    end
+
+    def handle_unknown_argument(arg)
+      if !@unknown_block || @unknown_block[arg.to_s]
+        @argv[:_] << ((@strings[:_] || !numeric?(arg)) ? arg : Numeric(arg))
+      end
+
+      !!@options[:stop_early]
+    end
+
+    def fill_with_defaults!
+      @defaults.each{ |key, value|
+        split_key_array = split_key_at_dots(key)
+        unless has_nested_key?(split_key_array)
+          set_key(split_key_array, value)
+          Array(@aliases[key] || []).each{ |sub_key|
+            split_sub_key_array = split_key_at_dots(sub_key)
+            set_key(split_sub_key_array, value)
+          }
+        end
+      }
+    end
+
+    def fill_with_non_flags!
+      if @options[:'--']
+        @argv[:'--'] = []
+        @not_flags.each{ |key| @argv[:'--'] << key }
+      else
+        @not_flags.each{ |key| @argv[:_] << key }
+      end
+    end
+
+    def argument_defined?(key, arg)
+      @all_bools && /\A--[^=]+\z/ =~ arg || @strings[key] || @bools[key] || @aliases[key]
+    end
+
+    def set_argument(key, value, arg = nil)
+      return if arg && @unknown_block && !argument_defined?(key, arg.to_sym) && !@unknown_block[arg.to_s]
+      value = (!@strings[key] && numeric?(value)) ? Numeric(value) : value
+      split_key = split_key_at_dots(key)
+      set_key(split_key, value)
+      Array(@aliases[key] || []).each{ |sub_key|
+        split_sub_key_array = split_key_at_dots(sub_key)
+        set_key(split_sub_key_array, value)
+      }
+    end
+
+    def set_key(keys, value)
+      o = @argv
+      keys[0..-2].each{ |key|
+        key = to_key_type(key)
+        o[key] = {} unless o.has_key?(key)
+        o = o[key]
+      }
+
+      key = to_key_type(keys[-1])
+
+      if !o.has_key?(key) || @bools[key] || o[key] == true || o[key] == false
+        o[key] = value
+      elsif o[key].is_a? Array
+        o[key] << value
+      else
+        o[key] = [o[key], value]
+      end
+    end
+
+    def next_arg_is_value?(key, next_arg, next_arg_regex, all_bools_true = true)
+      next_arg &&
+      next_arg !~ next_arg_regex &&
+      !@bools[key] &&
+      (all_bools_true || !@all_bools) &&
+      (@aliases[key] ? !(Array(@aliases[key]).any?{ |a| @bools[a] }) : true)
+    end
+
+    def numeric?(value)
+      value.is_a?(Numeric) ||
+      !(value !~ /\A0x[0-9a-f]+\z/) ||
+      !(value !~ /\A[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?\z/)
+    end
+
+    def Numeric(value)
+      case value
+      when Numeric
+        value
+      when /\A0x/
+        Integer(value)
+      when /\.|e/
+        Float(value)
+      else
+        Integer(value)
+      end
+    end
+
+    def to_key_type(key)
+      numeric?(key.to_s) ? Numeric(key.to_s) : key.to_sym
+    end
+
+    def split_key_at_dots(key)
+      if key.is_a?(Symbol) || key.is_a?(String)
+        key.to_s.split('.').map(&:to_sym)
+      else
+        Array(key)
+      end
+    end
+
+    def has_nested_key?(split_key_array)
+      catch :has_not do
+        split_key_array.reduce(@argv){ |acc, cur| (acc.has_key?(cur) or throw :has_not) && acc[cur] }
+        return true
+      end
+
+      false
+    end
+  end
+end

data/rationalist.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + "/lib/rationalist"
+
+Gem::Specification.new do |gem|
+  gem.name          = "rationalist"
+  gem.version       = Rationalist::VERSION
+  gem.summary       = "parse argument options"
+  gem.description   = "parse argument options. a ruby fork of minimist."
+  gem.authors       = ["Jan Lelis"]
+  gem.email         = ["mail@janlelis.de"]
+  gem.homepage      = "https://github.com/janlelis/Rationalist"
+  gem.license       = "MIT"
+
+  gem.files         = Dir["{**/}{.*,*}"].select{ |path| File.file?(path) && path !~ /^pkg/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = "~> 2.0"
+end

data/spec/all_bools_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'all bools' do
+  it 'flag boolean true (default all --args to boolean)' do
+    argv = Rationalist.parse(['moo', '--honk', 'cow'], {
+      boolean: true
+    })
+
+    argv.must_equal({
+      honk: true,
+      _: ['moo', 'cow']
+    })
+  end
+end

data/spec/bool_spec.rb

@@ -0,0 +1,106 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'bool' do
+  it 'flag boolean default false' do
+    argv = Rationalist.parse(['moo'], {
+      boolean: ['t', 'verbose'],
+      default: { verbose: false, t: false }
+    })
+
+    argv.must_equal({
+      verbose: false,
+      t: false,
+      _: ['moo']
+    })
+  end
+
+  it 'boolean groups' do
+    argv = Rationalist.parse(['-x', '-z', 'one', 'two', 'three'], {
+      boolean: ['x','y','z']
+    })
+
+    argv.must_equal({
+      x: true,
+      y: false,
+      z: true,
+      _: ['one', 'two', 'three']
+    })
+  end
+
+  it 'boolean and alias with chainable api' do
+    aliased = ['-h', 'derp']
+    regular = ['--herp',  'derp']
+    options = { herp: {alias: 'h', boolean: true} }
+    aliased_argv = Rationalist.parse(aliased, {
+      boolean: 'herp',
+      alias: { h: 'herp' }
+    })
+    property_argv = Rationalist.parse(regular, {
+      boolean: 'herp',
+      alias: { h: 'herp' }
+    })
+    expected = {
+      herp: true,
+      h: true,
+      _: ['derp']
+    };
+
+    aliased_argv.must_equal(expected);
+    property_argv.must_equal(expected);
+  end
+
+  it 'boolean and alias with options hash' do
+    aliased = ['-h', 'derp']
+    regular = ['--herp', 'derp']
+    options = {
+      alias: { h: 'herp' },
+      boolean: 'herp'
+    }
+
+    aliased_argv = Rationalist.parse(aliased, options)
+    property_argv = Rationalist.parse(regular, options)
+    expected = {
+      herp: true,
+      h: true,
+      _: ['derp']
+    }
+    aliased_argv.must_equal(expected);
+    property_argv.must_equal(expected);
+  end
+
+  it 'boolean and alias using explicit true' do
+    aliased = ['-h', 'true']
+    regular = ['--herp', 'true']
+    options = {
+      alias: { h: 'herp' },
+      boolean: 'h'
+    }
+
+    aliased_argv = Rationalist.parse(aliased, options)
+    property_argv = Rationalist.parse(regular, options)
+    expected = {
+      herp: true,
+      h: true,
+      _: []
+    }
+    aliased_argv.must_equal(expected);
+    property_argv.must_equal(expected);
+  end
+
+  it 'boolean and --x=true' do
+    parsed = Rationalist.parse(['--boool', '--other=true'], {
+      boolean: 'boool'
+    })
+    parsed[:boool].must_equal true
+    parsed[:other].must_equal 'true'
+
+    parsed = Rationalist.parse(['--boool', '--other=false'], {
+      boolean: 'boool'
+    })
+
+    parsed[:boool].must_equal true
+    parsed[:other].must_equal 'false'
+  end
+end

data/spec/dash_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'dash' do
+  it '-' do
+    Rationalist.parse(['-n', '-']).must_equal({ n: '-', _: [] })
+    Rationalist.parse(['-']).must_equal({ _: ['-'] })
+    Rationalist.parse(['-f-']).must_equal({ f: '-', _: [] })
+    Rationalist.parse(['-b', '-'], boolean: 'b').must_equal({ b: true, _: ['-'] })
+    Rationalist.parse(['-s', '-'], string: 's').must_equal({ s: '-', _: [] })
+  end
+
+  it '-a -- b' do
+    Rationalist.parse(['-a', '--', 'b']).must_equal({ a: true, _: ['b'] })
+    Rationalist.parse(['--a', '--', 'b']).must_equal({ a: true, _: ['b'] })
+  end
+
+  it 'move arguments after the -- into their own `--` array' do
+    Rationalist.parse(['--name', 'John', 'before', '--', 'after'], { :'--' => true }).must_equal(
+      { name: 'John', _: ['before'], :'--' => ['after'] }
+    )
+  end
+end

data/spec/default_bool_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'default bool' do
+  it 'boolean default true' do
+    argv = Rationalist.parse([], {
+        boolean: 'sometrue',
+        default: { sometrue: true }
+    });
+    argv[:sometrue].must_equal true
+  end
+
+  it 'boolean default false' do
+    argv = Rationalist.parse([], {
+        boolean: 'somefalse',
+        default: { somefalse: false }
+    });
+    argv[:somefalse].must_equal false
+  end
+
+  it 'boolean default to nil' do
+    argv = Rationalist.parse([], {
+        boolean: 'maybe',
+        default: { maybe: nil }
+    });
+    argv[:maybe].must_equal nil
+    argv = Rationalist.parse(['--maybe'], {
+        boolean: 'maybe',
+        default: { maybe: nil }
+    });
+    argv[:maybe].must_equal true
+  end
+end
+

data/spec/dotted_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'dotted' do
+  it 'dotted alias' do
+    argv = Rationalist.parse(['--a.b', '22'], { default: { :'a.b' => 11 }, alias: { :'a.b' => 'aa.bb' } });
+    argv[:a][:b].must_equal(22)
+    argv[:aa][:bb].must_equal(22)
+  end
+
+  it 'dotted default' do
+    argv = Rationalist.parse('', { default: { :'a.b' => 11 }, alias: { :'a.b' => 'aa.bb' } });
+    argv[:a][:b].must_equal(11)
+    argv[:aa][:bb].must_equal(11)
+  end
+
+  it 'dotted default with no alias' do
+    argv = Rationalist.parse('', { default: { :'a.b' => 11 } });
+    argv[:a][:b].must_equal(11)
+  end
+end
+

data/spec/long_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'long' do
+  it 'long boolean' do
+    Rationalist.parse([ '--bool' ]).must_equal({ bool: true, _: [] })
+  end
+
+  it 'long capture sp' do
+    Rationalist.parse([ '--pow', 'xixxle' ]).must_equal({ pow: 'xixxle', _: [] })
+  end
+
+  it 'long capture eq' do
+    Rationalist.parse([ '--pow=xixxle' ]).must_equal({ pow: 'xixxle', _: [] })
+  end
+
+  it 'long captures sp' do
+    Rationalist.parse([ '--host', 'localhost', '--port', '555' ]).must_equal({ host: 'localhost', port: 555, _: [] })
+  end
+
+  it 'long captures eq' do
+    Rationalist.parse([ '--host=localhost', '--port=555' ]).must_equal({ host: 'localhost', port: 555, _: [] })
+  end
+end

data/spec/num_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'num' do
+  it 'nums' do
+    argv = Rationalist.parse([
+      '-x', '1234',
+      '-y', '5.67',
+      '-z', '1e7',
+      '-w', '10f',
+      '--hex', '0xdeadbeef',
+      '789'
+    ])
+    argv.must_equal({
+      x: 1234,
+      y: 5.67,
+      z: 1e7,
+      w: '10f',
+      hex: 0xdeadbeef,
+      _: [789]
+    })
+  end
+
+  it 'already a number' do
+    argv = Rationalist.parse([ '-x', 1234, 789 ]);
+    argv.must_equal({ x: 1234, _: [789] });
+  end
+end

data/spec/parse_modified_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'parse modified' do
+  it 'parse with modifier functions' do
+    argv = Rationalist.parse([ '-b', '123' ], { boolean: 'b' })
+
+    argv.must_equal({
+      b: true,
+      _: [123]
+    })
+  end
+end

data/spec/parse_spec.rb

@@ -0,0 +1,148 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'Rationalist.parse' do
+  it 'parses no' do
+    Rationalist.parse(['--no-moo']).must_equal({ moo: false, _: [] })
+  end
+
+  it 'parses multiple times the same option' do
+    Rationalist.parse(['-v', 'a', '-v', 'b', '-v', 'c']).must_equal({ v: ['a','b','c'], _: [] })
+  end
+
+  it 'comprehensive' do
+    Rationalist.parse([
+      '--name=meowmers', 'bare', '-cats', 'woo',
+      '-h', 'awesome', '--multi=quux',
+      '--key', 'value',
+      '-b', '--bool', '--no-meep', '--multi=baz',
+      '--', '--not-a-flag', 'eek'
+    ]).must_equal({
+      c: true,
+      a: true,
+      t: true,
+      s: 'woo',
+      h: 'awesome',
+      b: true,
+      bool: true,
+      key: 'value',
+      multi: ['quux', 'baz'],
+      meep: false,
+      name: 'meowmers',
+      _: ['bare', '--not-a-flag', 'eek']
+    })
+  end
+
+  it 'flag boolean' do
+    Rationalist.parse(['-t', 'moo'], { boolean: 't' }).must_equal({ t: true, _: ['moo'] })
+  end
+
+  it 'flag boolean value' do
+    Rationalist.parse(['--verbose', 'false', 'moo', '-t', 'true'], {
+      boolean: ['t', 'verbose'],
+      default: { verbose: true }
+    }).must_equal({
+      verbose: false,
+      t: true,
+      _: ['moo'],
+    })
+  end
+
+  it 'newlines in params'  do
+    Rationalist.parse(['-s', "X\nX"]).must_equal({ _: [], s: "X\nX" })
+
+    # reproduce in bash:
+    # VALUE="new
+    # line"
+    # node program.js --s="$VALUE"
+    Rationalist.parse(["--s=X\nX"]).must_equal({ _: [], s: "X\nX" })
+  end
+
+  it 'strings'  do
+    Rationalist.parse(['-s', '0001234'], { string: 's' })[:s].must_equal('0001234')
+    Rationalist.parse(['-x', '56'], { string: 'x' })[:x].must_equal('56')
+  end
+
+  it 'stringArgs' do
+    Rationalist.parse(['  ', '  '], { string: '_' })[:_].must_equal(
+      ['  ', '  ']
+    )
+  end
+
+  it 'empty strings' do
+    Rationalist.parse(['-s'], { string: 's' })[:s].must_equal('')
+    Rationalist.parse(['--str'], { string: 'str' })[:str].must_equal('')
+
+    letters = Rationalist.parse(['-art'], {
+      string: ['a', 't']
+    })
+    letters[:a].must_equal('')
+    letters[:r].must_equal(true)
+    letters[:t].must_equal('')
+  end
+
+  it 'string and alias' do
+    x = Rationalist.parse(['--str',  '000123'], {
+      string: 's',
+      alias: { s: 'str' }
+    })
+
+    x[:str].must_equal('000123')
+    x[:s].must_equal('000123')
+
+    y = Rationalist.parse(['-s',  '000123'], {
+      string: 'str',
+      alias: { str: 's' }
+    })
+
+    y[:str].must_equal('000123')
+    y[:s].must_equal('000123')
+  end
+
+  it 'slashBreak' do
+    Rationalist.parse(['-I/foo/bar/baz']).must_equal({ I: '/foo/bar/baz', _: [] })
+    Rationalist.parse(['-xyz/foo/bar/baz']).must_equal(
+      { x: true, y: true, z: '/foo/bar/baz', _: [] }
+    )
+  end
+
+  it 'alias' do
+    argv = Rationalist.parse(['-f', '11', '--zoom', '55'], {
+      alias: { z: 'zoom' }
+    })
+
+    argv[:zoom].must_equal(55)
+    argv[:z].must_equal(argv[:zoom])
+    argv[:f].must_equal(11)
+  end
+
+  it 'multiAlias' do
+    argv = Rationalist.parse(['-f', '11', '--zoom', '55'], {
+      alias: { z: ['zm', 'zoom'] }
+    })
+
+    argv[:zoom].must_equal(55)
+    argv[:z].must_equal(argv[:zoom])
+    argv[:z].must_equal(argv[:zm])
+    argv[:f].must_equal(11)
+  end
+
+  it 'nested dotted objects' do
+    argv = Rationalist.parse([
+      '--foo.bar', '3', '--foo.baz', '4',
+      '--foo.quux.quibble', '5', '--foo.quux.o_O',
+      '--beep.boop'
+    ])
+
+    argv[:foo].must_equal({
+      bar: 3,
+      baz: 4,
+      quux: {
+        quibble: 5,
+        o_O: true
+      },
+    })
+    argv[:beep].must_equal({ boop: true })
+  end
+end

data/spec/short_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'short' do
+  it 'numeric' do
+    Rationalist.parse(['-n123']).must_equal({ n: 123, _: [] })
+    Rationalist.parse(['-123', '456']).must_equal({ 1 => true, 2 => true, 3 => 456, _: [] })
+  end
+
+  it 'boolean' do
+    Rationalist.parse(['-b']).must_equal({ b: true, _: [] })
+  end
+
+  it 'bare' do
+    Rationalist.parse(['foo', 'bar', 'baz']).must_equal({ _: ['foo', 'bar', 'baz'] })
+  end
+
+  it 'group' do
+    Rationalist.parse(['-cats']).must_equal({ c: true, a: true, t: true, s: true, _: [] })
+  end
+
+  it 'group next' do
+    Rationalist.parse(['-cats', 'meow']).must_equal({ c: true, a: true, t: true, s: 'meow', _: [] })
+  end
+
+  it 'short capture' do
+    Rationalist.parse(['-h', 'localhost']).must_equal({ h: 'localhost', _: [] })
+  end
+
+  it 'short captures' do
+    Rationalist.parse(['-h', 'localhost', '-p', '555']).must_equal({ h: 'localhost', p: 555, _: [] })
+  end
+
+  it 'mixed short bool and capture' do
+    Rationalist.parse(['-h', 'localhost', '-fp', '555', 'script.js']).must_equal({
+      f: true, p: 555, h: 'localhost',
+      _: ['script.js'],
+    })
+  end
+
+  it 'short and long' do
+    Rationalist.parse(['-h', 'localhost', '-fp', '555', 'script.js']).must_equal({
+      f: true, p: 555, h: 'localhost',
+      _: ['script.js'],
+    })
+  end
+end

data/spec/stop_early_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'stop early' do
+  it 'stops parsing on the first non-option when stopEarly is set' do
+    argv = Rationalist.parse(
+     ['--aaa', 'bbb', 'ccc', '--ddd'],
+      stop_early: true,
+    )
+
+    argv.must_equal(
+      aaa: 'bbb',
+      _: ['ccc', '--ddd'],
+    )
+  end
+end

data/spec/unknown_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'unknown' do
+  it 'boolean and alias is not unknown' do
+    unknown = []
+    unknown_block = ->(arg){
+      unknown.push(arg)
+      false
+    }
+    aliased = ['-h', 'true', '--derp', 'true']
+    regular = ['--herp',  'true', '-d', 'true']
+    opts = {
+      alias: { h: 'herp' },
+      boolean: 'h',
+    }
+    aliased_argv = Rationalist.parse(aliased, opts, &unknown_block)
+    property_argv = Rationalist.parse(regular, opts, &unknown_block)
+
+    unknown.must_equal(['--derp', '-d'])
+  end
+
+  it 'flag boolean true any double hyphen argument is not unknown' do
+    unknown = []
+    unknown_block = ->(arg){
+      unknown.push(arg)
+      false
+    }
+
+    argv = Rationalist.parse(['--honk', '--tacos=good', 'cow', '-p', '55'], {
+      boolean: true,
+    }, &unknown_block)
+
+    unknown.must_equal(['--tacos=good', 'cow', '-p'])
+    argv.must_equal({
+      honk: true,
+      _: []
+    })
+  end
+
+  it 'string and alias is not unknown' do
+    unknown = []
+    unknown_block = ->(arg){
+      unknown.push(arg)
+      false
+    }
+
+    aliased = ['-h', 'hello', '--derp', 'goodbye']
+    regular = ['--herp',  'hello', '-d', 'moon']
+    opts = {
+      alias: { h: 'herp' },
+      string: 'h',
+    }
+
+    aliased_argv = Rationalist.parse(aliased, opts, &unknown_block)
+    property_argv = Rationalist.parse(regular, opts, &unknown_block)
+
+    unknown.must_equal(['--derp', '-d'])
+  end
+
+  it 'default and alias is not unknown' do
+    unknown = []
+    unknown_block = ->(arg){
+      unknown.push(arg)
+      false
+    }
+
+    aliased = ['-h', 'hello']
+    regular = ['--herp',  'hello']
+    opts = {
+      default: { h: 'bar' },
+      alias: { h: 'herp' },
+    }
+    aliased_argv = Rationalist.parse(aliased, opts, &unknown_block)
+    property_argv = Rationalist.parse(regular, opts, &unknown_block)
+
+    unknown.must_equal([])
+    unknown_block.call(nil) # exercise fn for 100% coverage
+  end
+
+  it 'value following -- is not unknown' do
+    unknown = []
+    unknown_block = ->(arg){
+      unknown.push(arg)
+      false
+    }
+
+    aliased = ['--bad', '--', 'good', 'arg']
+    opts = {
+      :'--' => true,
+    }
+    argv = Rationalist.parse(aliased, opts, &unknown_block)
+
+    unknown.must_equal(['--bad'])
+    argv.must_equal({
+      :'--' => ['good', 'arg'],
+      :_ => [],
+    })
+  end
+end

data/spec/whitespace_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../lib/rationalist'
+require 'minitest/autorun'
+require 'minitest/expectations'
+
+describe 'whitespace' do
+  it 'whitespace should be whitespace' do
+    Rationalist.parse([ '-x', "\t" ])[:x].must_equal "\t"
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: rationalist
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Jan Lelis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-09 00:00:00.000000000 Z
+dependencies: []
+description: parse argument options. a ruby fork of minimist.
+email:
+- mail@janlelis.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- example/parse.rb
+- lib/rationalist.rb
+- rationalist.gemspec
+- spec/all_bools_spec.rb
+- spec/bool_spec.rb
+- spec/dash_spec.rb
+- spec/default_bool_spec.rb
+- spec/dotted_spec.rb
+- spec/long_spec.rb
+- spec/num_spec.rb
+- spec/parse_modified_spec.rb
+- spec/parse_spec.rb
+- spec/short_spec.rb
+- spec/stop_early_spec.rb
+- spec/unknown_spec.rb
+- spec/whitespace_spec.rb
+homepage: https://github.com/janlelis/Rationalist
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: parse argument options
+test_files:
+- spec/all_bools_spec.rb
+- spec/bool_spec.rb
+- spec/dash_spec.rb
+- spec/default_bool_spec.rb
+- spec/dotted_spec.rb
+- spec/long_spec.rb
+- spec/num_spec.rb
+- spec/parse_modified_spec.rb
+- spec/parse_spec.rb
+- spec/short_spec.rb
+- spec/stop_early_spec.rb
+- spec/unknown_spec.rb
+- spec/whitespace_spec.rb
+has_rdoc: