opt 0.1.0

data/spec/opt/option_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+RSpec::Matchers.define :parse do |*expected|
+  match do |option|
+    result = {}
+    argv   = expected.dup
+    option.parse!(argv, result)
+
+    expect(result).to include results  if results.any?
+    expect(argv).to eq expected[1..-1] if shift?
+  end
+
+  chain :emit do |hash|
+    results.merge! hash
+  end
+
+  chain :shift_argv do
+    @shift = true
+  end
+
+  def shift?
+    @shift.nil? ? (@shift = false) : @shift
+  end
+
+  def results
+    @results ||= {}
+  end
+end
+
+def t(type, value)
+  Opt::Command::Token.new(type, value)
+end
+
+describe Opt::Option do
+  let(:option) { described_class.new(defin, {name: :test}.merge(opts)) }
+  let(:defin) { '' }
+  let(:opts)  { {} }
+  subject { option }
+
+  describe '.parse_nargs' do
+    it 'should parse single fixnum' do
+      expect(described_class.parse_nargs(5)).to eq 5..5
+    end
+
+    it 'should parse range' do
+      expect(described_class.parse_nargs(2..6)).to eq 2..6
+    end
+
+    it 'should parse fixnum string' do
+      expect(described_class.parse_nargs('12')).to eq 12..12
+    end
+
+    it 'should parse special infinity string' do
+      expect(described_class.parse_nargs('*')).to eq 0..Float::INFINITY
+    end
+
+    it 'should parse special infinity symbol (I)' do
+      expect(described_class.parse_nargs(:inf)).to eq 0..Float::INFINITY
+    end
+
+    it 'should parse special infinity symbol (II)' do
+      expect(described_class.parse_nargs(:infinity)).to eq 0..Float::INFINITY
+    end
+
+    it 'should parse array (I)' do
+      expect(described_class.parse_nargs([3, :inf])).to eq 3..Float::INFINITY
+    end
+
+    it 'should parse array (II)' do
+      expect(described_class.parse_nargs([3, 100])).to eq 3..100
+    end
+
+    it 'should reject invalid string' do
+      expect do
+        described_class.parse_nargs('a12')
+      end.to raise_error(/invalid value for Integer/)
+    end
+
+    it 'should flip negative range' do
+      expect(described_class.parse_nargs(6..2)).to eq 2..6
+    end
+
+    it 'should reject negative range' do
+      expect do
+        described_class.parse_nargs(-2..2)
+      end.to raise_error(/Argument number must not be less than zero/)
+    end
+  end
+
+  describe '#initialize' do
+    it 'should derive name from switches (I)' do
+      expect(described_class.new('-h').name).to eq 'h'
+    end
+
+    it 'should derive name from switches (II)' do
+      expect(described_class.new('--help').name).to eq 'help'
+    end
+
+    it 'should use name from opts' do
+      expect(described_class.new('--help', name: :test).name).to eq 'test'
+    end
+
+    it 'should parse switches' do
+      option = described_class.new('-h, --help')
+      expect(option.switches.size).to eq 2
+      expect(option.switches.each.map(&:name)).to match_array %w(h help)
+    end
+
+    it 'should parse free-text arg' do
+      option = described_class.new('file', nargs: 0..Float::INFINITY)
+      expect(option.switches.size).to eq 0
+      expect(option).to be_text
+      expect(option.name).to eq 'file'
+    end
+  end
+
+  describe '#parse!' do
+    context 'with shirt code' do
+      let(:defin) { '-h, -2, -め' }
+
+      it 'should match short token' do
+        option.parse! argv = [t(:short, 'h')], result = {}
+
+        expect(argv).to be_empty
+        expect(result).to eq 'test' => true
+      end
+
+      it 'should match grouped short token' do
+        option.parse! argv = [t(:short, '2b4')], result = {}
+
+        expect(argv.size).to eq 1
+        expect(argv.first.value).to eq 'b4'
+        expect(result).to eq 'test' => true
+      end
+
+      it 'should match short unicode token' do
+        option.parse! argv = [t(:short, 'め')], result = {}
+
+        expect(argv).to be_empty
+        expect(result).to eq 'test' => true
+      end
+
+      it 'should not match long token' do
+        option.parse! argv = [t(:long, 'め')], result = {}
+
+        expect(argv.size).to eq 1
+        expect(result).to be_empty
+      end
+
+      it 'should not match different short token' do
+        option.parse! argv = [t(:short, '1')], result = {}
+
+        expect(argv.size).to eq 1
+        expect(result).to be_empty
+      end
+    end
+
+    context 'with long code' do
+      let(:defin) { '--help, --2, --めこそ' }
+
+      it 'should match long argv (I)' do
+        option.parse! argv = [t(:long, 'help')], result = {}
+
+        expect(argv).to be_empty
+        expect(result).to eq 'test' => true
+      end
+
+      it 'should match long argv (II)' do
+        option.parse! argv = [t(:long, '2')], result = {}
+
+        expect(argv).to be_empty
+        expect(result).to eq 'test' => true
+      end
+
+      it 'should match long argv (III)' do
+        option.parse! argv = [t(:long, 'めこそ')], result = {}
+
+        expect(argv).to be_empty
+        expect(result).to eq 'test' => true
+      end
+    end
+
+    context 'with free-text' do
+      let(:defin) { 'file' }
+      let(:opts) { {nargs: 1} }
+
+      it 'should match text' do
+        option.parse! argv = [t(:text, 'help')], result = {}
+
+        expect(argv).to be_empty
+        expect(result).to eq 'test' => 'help'
+      end
+
+      context 'with lower bound' do
+        let(:opts) { {nargs: 2..Float::INFINITY} }
+
+        it 'should reject to less arguments' do
+          expect do
+            option.parse! [t(:text, 'a')], {}
+          end.to raise_error(/wrong number of arguments/)
+        end
+
+        it 'should accept enough arguments' do
+          option.parse! argv = [t(:text, 'a'), t(:text, 'b')], result = {}
+
+          expect(argv).to be_empty
+          expect(result).to eq 'test' => %w(a b)
+        end
+      end
+
+      context 'with upper bound' do
+        let(:opts) { {nargs: 0..2} }
+
+        it 'should eat arguments up to upper bound' do
+          option.parse! argv   = [t(:text, 'a'), t(:text, 'b'), t(:text, 'c')],
+                        result = {}
+
+          expect(argv).to eq [t(:text, 'c')]
+          expect(result).to eq 'test' => %w(a b)
+        end
+
+        it 'should eat less arguments if there are less tokens' do
+          option.parse! argv = [t(:text, 'a'), t(:short, 'b'), t(:text, 'c')],
+                        result = {}
+
+          expect(argv).to eq [t(:short, 'b'), t(:text, 'c')]
+          expect(result).to eq 'test' => %w(a)
+        end
+      end
+    end
+  end
+end

data/spec/opt/switch_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Opt::Switch do
+  describe '.new' do
+    subject { described_class.new arg }
+
+    context 'with Switch object' do
+      let(:arg) { described_class.new '-x' }
+
+      it 'should return original switch object' do
+        is_expected.to eql arg
+      end
+    end
+  end
+
+  describe '#initialize' do
+    subject { described_class.new arg }
+
+    context 'with short code string' do
+      let(:arg) { '-h' }
+
+      it 'should parse to short code' do
+        expect(subject).to be_short
+        expect(subject.name).to eq 'h'
+      end
+    end
+
+    context 'with long code string' do
+      let(:arg) { '--help' }
+
+      it 'should parse to long code' do
+        expect(subject).to be_long
+        expect(subject.name).to eq 'help'
+      end
+    end
+
+    context 'with unicode parameter string' do
+      let(:arg) { '--めこそ' }
+
+      it 'should parse to long code' do
+        expect(subject).to be_long
+        expect(subject.name).to eq 'めこそ'
+      end
+    end
+  end
+
+  describe '.parse' do
+    subject { described_class.parse arg }
+
+    context 'with string' do
+      let(:arg) { '-h, --help, -h' }
+
+      it 'should parse to Set' do
+        expect(subject).to be_a Set
+        expect(subject.size).to eq 2
+        expect(subject.map(&:name)).to match_array %w(h help)
+      end
+    end
+  end
+end

data/spec/opt_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Opt do
+  let(:opt) { Opt.new }
+
+  it 'should parse options (I)' do
+    opt.option '--help, -h', value: :yes
+
+    result = opt.parse %w(-h)
+    expect(result.help).to eq :yes
+
+    result = opt.parse %w()
+    expect(result.help).to eq nil
+  end
+
+  it 'should detect double-dash' do
+    opt.option '-v', name: :version
+    opt.option 'rest', nargs: '+'
+
+    result = opt.parse %w(-v -- -h)
+    expect(result.version?).to be true
+    expect(result.rest).to eq %w(-h)
+  end
+
+  it 'should parse options (II)' do
+    opt.option '--help', default: :no
+    opt.option '--version'
+
+    result = opt.parse %w(--version)
+    expect(result.version).to eql true
+    expect(result.help).to eql :no
+  end
+
+  it 'should parse options with argument' do
+    opt.option '--level, -l', nargs: 1
+
+    result = opt.parse %w(--level 5)
+    expect(result.level).to eq '5'
+
+    result = opt.parse %w(--level=5)
+    expect(result.level).to eq '5'
+
+    result = opt.parse %w(-l 5)
+    expect(result.level).to eq '5'
+
+    result = opt.parse %w(-l5)
+    expect(result.level).to eq '5'
+  end
+
+  it 'should parse options with arguments' do
+    opt.option '--level, -l', nargs: 2..3
+
+    result = opt.parse %w(--level 5 6)
+    expect(result.level).to eq %w(5 6)
+
+    result = opt.parse %w(-l 5 6)
+    expect(result.level).to eq %w(5 6)
+  end
+
+  it 'should parse flags' do
+    pending
+
+    opt.option :force, '-f, --force', default: false
+    opt.option :quiet, '-q, --quiet', default: true
+
+    result = opt.parse %w(--force)
+    expect(result[:force]).to be true
+    expect(result[:quiet]).to be true
+
+    result = opt.parse %w(--no-force -q)
+    expect(result[:force]).to be false
+    expect(result[:quiet]).to be true
+
+    result = opt.parse %w(-f --no-quiet)
+    expect(result[:force]).to be true
+    expect(result[:quiet]).to be false
+
+    result = opt.parse %w(--no-quiet)
+    expect(result[:force]).to be false
+    expect(result[:quiet]).to be false
+  end
+
+  it 'should parse subcommands (I)' do
+    opt.option '--force, -f'
+
+    opt.command :add, 'Add some things' do |cmd|
+      cmd.option '--verbose'
+    end
+
+    result = opt.parse %w(-f add --verbose)
+
+    expect(result.force?).to eq true
+    expect(result.verbose?).to eq true
+    expect(result.command).to eq %w(add)
+
+    result = opt.parse %w(add -f --verbose)
+
+    expect(result.force?).to eq true
+    expect(result.verbose?).to eq true
+    expect(result.command).to eq %w(add)
+  end
+
+  it 'should parse subcommands (II)' do
+    opt.option '-f'
+
+    opt.command :add, 'Add some things' do |cmd|
+      cmd.option '-a'
+      cmd.option '-j', nargs: 1
+    end
+
+    result = opt.parse %w(add -af)
+
+    expect(result.a?).to eq true
+    expect(result.f?).to eq true
+    expect(result.command).to eq %w(add)
+
+    result = opt.parse %w(add -ajf)
+
+    expect(result.a?).to eq true
+    expect(result.f?).to eq nil
+    expect(result.j).to eq 'f'
+    expect(result.command).to eq %w(add)
+  end
+end

data/spec/readme_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Opt do
+  let(:opt) { Opt.new }
+
+  it 'should pass README examples' do
+    content = File.read(File.expand_path('../../README.md', __FILE__))
+
+    while content =~ /^```ruby\n(.*?)^```\n(.*?)\z/m
+      example = $1
+      content = $2
+
+      example.gsub!(/^\s*(.*?)\s*#=>\s*(.*?)\s*$/, 'expect( \1 ).to eq( \2 )')
+
+      instance_eval example, __FILE__, __LINE__
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+
+if ENV['CI'] || ENV['COVERAGE']
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter 'spec'
+  end
+end
+
+# Load stic
+require 'opt'
+
+# Load spec support files
+Dir[File.expand_path('spec/support/**/*.rb')].each {|f| require f }
+
+RSpec.configure do |config|
+  # Random order
+  config.order = 'random'
+end