yawpa 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDQxOWYxMWMwMjA3NjU5NjlkOTQ4MTFkM2Y3OTZkNTI5MGVjNzJiZg==
+  data.tar.gz: !binary |-
+    YzQ1NGE3MDM1MjJkNjRiMjM0MTJjMDFiNmRmNmVhODJiZWNmMjVlMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTdjNTBkMTM5NDY5MmNjMTYwY2VmNmU4NjRhMjM0MjVjYTM3YjM3MTY0OWY3
+    MjY4M2U1NTI5ZTZlZmM3N2E2MDU2YmE3MTBiYzEyZWQxODA5NzEwOTA2YjM3
+    ZDMwNzQzNmJhOTRhN2FlZGZjNDFiNDYyYWM0OTQ4NmNlMjZhNTk=
+  data.tar.gz: !binary |-
+    OWExNTUyNmE4ODM1YTFiNWMwNTg4YjdmMTU1MWJiOTM2ZmUxNmFiMjc3ZjI1
+    YWQxMWU1ZTU2MjZjMTA0NTc2MmFjOWJkOWVhMjk4ZDdlMmQ3ZDk0ZDI2M2Vl
+    MzI0NmQ5YmEyNTA3NGIxMjdhYjE4ZTYxZjIzYTgwMDI4YmUxY2I=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yawpa.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Josh Holtrop
+
+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,65 @@
+# Yawpa
+
+Yet Another Way to Parse Arguments is an argument-parsing library for Ruby.
+
+## Features
+
+- POSIX or non-POSIX mode (supports subcommands using POSIX mode)
+- Options can require an arbitrary number of parameters
+- Options can be defined with a range specifying the allowed number of parameters
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'yawpa'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yawpa
+
+## Example 1
+
+    require 'yawpa'
+
+    options = {
+      version: {},
+      verbose: {short: 'v'},
+      get: {nargs: 1},
+      set: {nargs: 2},
+    }
+    opts, args = Yawpa.parse(ARGV, options)
+    opts.each_pair do |opt, val|
+    end
+
+## Example 2
+
+    require 'yawpa'
+
+    options = {
+      version: {},
+      help: {short: 'h'},
+    }
+    opts, args = Yawpa.parse(ARGV, options, posix_order: true)
+    if opts[:version]
+      puts "my app, version 1.2.3"
+    end
+    if args[0] == 'subcommand'
+      subcommand_options = {
+        'server': {nargs: (1..2), short: 's'},
+        'dst': {nargs: 1, short: 'd'},
+      }
+      opts, args = Yawpa.parse(args, subcommand_options)
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require "rdoc/task"
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Yet Another Way to Parse Arguments'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/yawpa/version.rb

@@ -0,0 +1,4 @@
+module Yawpa
+  # gem version
+  VERSION = "1.0.0"
+end

data/lib/yawpa.rb

@@ -0,0 +1,162 @@
+require "yawpa/version"
+
+# Yet Another Way to Parse Arguments is an argument-parsing library for Ruby.
+#
+# Yawpa does not try to provide a fancy DSL.
+# It does not require you to define a class or inherit from a class.
+# it just provides a simple functional interface for parsing options,
+# supporting subcommands and arbitrary numbers of arguments for each option.
+#
+# == Features
+#
+# - POSIX or non-POSIX mode (supports subcommands using POSIX mode)
+# - Options can require an arbitrary number of parameters
+# - Options can be defined with a range specifying the allowed number of parameters
+module Yawpa
+  # Exception class raised when an unknown option is observed
+  class ArgumentParsingException < Exception; end
+
+  module_function
+  # :call-seq:
+  #   opts, args = parse(params, options, flags = {})
+  #
+  # Parse input parameters looking for options according to rules given in flags
+  #
+  # - +params+ is the list of program parameters to parse.
+  # - +options+ is a hash containing the long option names as keys, and hashes
+  #   containing special flags for the options as values (example below).
+  # - +flags+ is optional. It supports the following keys:
+  #   - +:posix_order+: Stop processing parameters when a non-option is seen.
+  #     Set this to +true+ if you want to implement subcommands.
+  #
+  # An ArgumentParsingException will be raised if an unknown option is observed
+  # or insufficient arguments are present for an option.
+  #
+  # == Example +options+
+  #
+  #   {
+  #     version: {},
+  #     verbose: {short: 'v'},
+  #     server: {nargs: (1..2)},
+  #     username: {nargs: 1},
+  #     password: {nargs: 1},
+  #   }
+  #
+  # The keys of the +options+ hash can be either strings or symbols.
+  #
+  # Options that have no special flags should have an empty hash as the value.
+  #
+  # Possible option flags:
+  # - +:short+: specify a short option letter to associate with the long option
+  # - +:nargs+: specify an exact number or range of possible numbers of
+  #   arguments to the option
+  #
+  # == Return values
+  #
+  # The returned +opts+ value will be a hash with the observed options as
+  # keys and any option arguments as values.
+  # The returned +args+ will be an array of the unprocessed parameters (if
+  # +:posix_order+ was passed in +flags+, this array might contain further
+  # options that were not processed after observing a non-option parameters.
+  def parse(params, options, flags = {})
+    options = _massage_options(options)
+    opts = {}
+    args = []
+    i = 0
+    while i < params.length
+      param = params[i]
+      if param =~ /^--([^=]+)(?:=(.+))?$/
+        param_name, val = $1, $2
+        if options[param_name].nil?
+          raise ArgumentParsingException.new("Unknown option '#{param_name}'")
+        end
+        opt_config = options[param_name]
+        param_key = opt_config[:key]
+        if opt_config[:nargs].last == 0
+          opts[param_key] = true
+        else
+          opts[param_key] = []
+          i += _gather(opt_config[:nargs], i + 1, params, val, param_key, opts[param_key])
+        end
+      elsif param =~ /^-(.+)$/
+        short_flags = $1
+        short_idx = 0
+        while short_idx < short_flags.length
+          opt_config = _find_opt_config_by_short_name(options, short_flags[short_idx])
+          if opt_config.nil?
+            raise ArgumentParsingException.new("Unknown option '-#{short_flags[short_idx]}'")
+          end
+          param_key = opt_config[:key]
+          if opt_config[:nargs].last == 0
+            opts[param_key] = true
+          else
+            opts[param_key] = []
+            i += _gather(opt_config[:nargs], i + 1, params, short_flags[short_idx + 1, short_flags.length], param_key, opts[param_key])
+            break
+          end
+          short_idx += 1
+        end
+      elsif flags[:posix_order]
+        args = params[i, params.length]
+        break
+      else
+        args << params[i]
+      end
+      i += 1
+    end
+
+    # Condense 1-element arrays of option values to just the element itself
+    opts.each_key do |k|
+      if opts[k].class == Array and opts[k].length == 1
+        opts[k] = opts[k].first
+      end
+    end
+
+    return [opts, args]
+  end
+
+  # Internal helper method to gather arguments for an option
+  def _gather(nargs, start_idx, params, initial, param_key, result) # :nodoc:
+    n_gathered = 0
+    if initial and initial != ''
+      result << initial
+      n_gathered += 1
+    end
+    num_indices_used = 0
+    index = start_idx
+    while n_gathered < nargs.last and
+          index < params.length and
+          params[index][0] != '-' do
+      result << params[index]
+      index += 1
+      num_indices_used += 1
+      n_gathered += 1
+    end
+    if n_gathered < nargs.first
+      raise ArgumentParsingException.new("Not enough arguments supplied for option '#{param_key}'")
+    end
+    num_indices_used
+  end
+
+  # Internal helper method to format the options in a consistent format
+  def _massage_options(options) # :nodoc:
+    {}.tap do |newopts|
+      options.each_pair do |k, v|
+        newkey = k.to_s
+        newopts[newkey] = {key: k}
+        nargs = v[:nargs] || 0
+        nargs = (nargs..nargs) if nargs.class == Fixnum
+        newopts[newkey][:nargs] = nargs
+        newopts[newkey][:short] = v[:short] || ''
+      end
+    end
+  end
+
+  # Internal helper method to find an option configuration by short name
+  def _find_opt_config_by_short_name(options, short_name) # :nodoc:
+    options.each_pair do |k, v|
+      return v if v[:short] == short_name
+    end
+    nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+require 'yawpa'
+
+RSpec.configure do |config|
+end

data/spec/yawpa_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe Yawpa do
+  describe 'parse' do
+    it "returns everything as arguments when no options present" do
+      options = { }
+      params = ['one', 'two', 'three', 'four']
+      opts, args = Yawpa.parse(params, options)
+      opts.should eq({})
+      args.should eq(params)
+    end
+
+    it "raises an exception when an invalid option is passed" do
+      options = { }
+      params = ['one', '--option', 'two']
+      expect { Yawpa.parse(params, options) }.to raise_error
+    end
+
+    it "returns boolean options which are set" do
+      options = {
+        one: {},
+        two: {},
+        three: {},
+      }
+      params = ['--one', 'arg', '--two', 'arg2']
+      opts, args = Yawpa.parse(params, options)
+      opts.include?(:one).should be_true
+      opts.include?(:two).should be_true
+      opts.include?(:three).should be_false
+      args.should eq(['arg', 'arg2'])
+    end
+
+    it "returns an option's value when nargs = 1" do
+      options = {
+        opt: {nargs: 1},
+      }
+      params = ['--opt', 'val', 'arg']
+      opts, args = Yawpa.parse(params, options)
+      opts[:opt].should eq('val')
+      args.should eq(['arg'])
+    end
+
+    it "returns an option's values when nargs = 2" do
+      options = {
+        opt: {nargs: 2},
+      }
+      params = ['--opt', 'val1', 'val2']
+      opts, args = Yawpa.parse(params, options)
+      opts[:opt].should eq(['val1', 'val2'])
+      args.should be_empty
+    end
+
+    it "raises an exception when not enough arguments for an option are given" do
+      options = {
+        opt: {nargs: 2},
+      }
+      params = ['--opt', 'val']
+      expect { Yawpa.parse(params, options) }.to raise_error
+    end
+
+    it "uses --opt=val syntax for an option's value" do
+      options = {
+        opt: {nargs: 1},
+      }
+      params = ['--opt=thevalue', 'arg']
+      opts, args = Yawpa.parse(params, options)
+      opts[:opt].should eq('thevalue')
+      args.should eq(['arg'])
+    end
+
+    it "uses --opt=val for the first option argument when nargs > 1" do
+      options = {
+        opt: {nargs: 2},
+      }
+      params = ['--opt=val1', 'val2', 'arg']
+      opts, args = Yawpa.parse(params, options)
+      opts[:opt].should eq(['val1', 'val2'])
+      args.should eq(['arg'])
+    end
+
+    it "returns the last set value when an option is passed twice" do
+      options = {
+        opt: {nargs: 1},
+      }
+      params = ['--opt', 'val1', 'arg1', '--opt', 'val2', 'arg2']
+      opts, args = Yawpa.parse(params, options)
+      opts[:opt].should eq('val2')
+      args.should eq(['arg1', 'arg2'])
+    end
+
+    it "accepts strings as keys for option configuration" do
+      options = {
+        'crazy-option' => {nargs: 1},
+      }
+      params = ['xxx', '--crazy-option', 'yyy', 'zzz']
+      opts, args = Yawpa.parse(params, options)
+      opts['crazy-option'].should eq('yyy')
+      args.should eq(['xxx', 'zzz'])
+    end
+
+    it "accepts short options corresponding to a long option" do
+      options = {
+        option: {short: 'o'},
+      }
+      params = ['-o', 'qqq']
+      opts, args = Yawpa.parse(params, options)
+      opts[:option].should be_true
+      args.should eq(['qqq'])
+    end
+
+    it "returns option argument at next position for a short option" do
+      options = {
+        option: {nargs: 1, short: 'o'},
+      }
+      params = ['-o', 'val', 'rrr']
+      opts, args = Yawpa.parse(params, options)
+      opts[:option].should eq('val')
+      args.should eq(['rrr'])
+    end
+
+    it "returns option argument immediately following short option" do
+      options = {
+        option: {nargs: 1, short: 'o'},
+      }
+      params = ['-oval', 'rrr']
+      opts, args = Yawpa.parse(params, options)
+      opts[:option].should eq('val')
+      args.should eq(['rrr'])
+    end
+
+    it "handles globbed-together short options" do
+      options = {
+        a: {short: 'a'},
+        b: {short: 'b'},
+        c: {short: 'c'},
+        d: {short: 'd'},
+      }
+      params = ['-abc', 'xyz']
+      opts, args = Yawpa.parse(params, options)
+      opts[:a].should be_true
+      opts[:b].should be_true
+      opts[:c].should be_true
+      opts[:d].should be_nil
+      args.should eq(['xyz'])
+    end
+
+    it "handles globbed-together short options with values following" do
+      options = {
+        a: {short: 'a'},
+        b: {short: 'b'},
+        c: {nargs: 1, short: 'c'},
+        d: {short: 'd'},
+      }
+      params = ['-abcfoo', 'bar']
+      opts, args = Yawpa.parse(params, options)
+      opts[:a].should be_true
+      opts[:b].should be_true
+      opts[:c].should eq('foo')
+      opts[:d].should be_nil
+      args.should eq(['bar'])
+    end
+
+    it "handles globbed-together short options with multiple values following" do
+      options = {
+        a: {short: 'a'},
+        b: {short: 'b'},
+        c: {nargs: 3, short: 'c'},
+        d: {short: 'd'},
+      }
+      params = ['-abcfoo', 'bar', 'baz']
+      opts, args = Yawpa.parse(params, options)
+      opts[:a].should be_true
+      opts[:b].should be_true
+      opts[:c].should eq(['foo', 'bar', 'baz'])
+      opts[:d].should be_nil
+      args.should be_empty
+    end
+
+    it "raises an error on an unknown short option" do
+      options = {
+        a: {short: 'a'},
+      }
+      params = ['-ab']
+      expect { Yawpa.parse(params, options) }.to raise_error
+    end
+
+    it "raises an error when not enough arguments are given to short option" do
+      options = {
+        a: {nargs: 1, short: 'a'},
+      }
+      params = ['-a']
+      expect { Yawpa.parse(params, options) }.to raise_error
+    end
+
+    it "overwrites option value when short option used after long" do
+      options = {
+        option: {nargs: 1, short: 'o'},
+      }
+      params = ['--option', 'VALUE', '-o', 'NEW_VALUE']
+      opts, args = Yawpa.parse(params, options)
+      opts[:option].should eq('NEW_VALUE')
+      args.should be_empty
+    end
+
+    it "ignores options after arguments in posix_order mode" do
+      options = {
+        one: {},
+        two: {},
+      }
+      params = ['--one', 'arg', '--two']
+      opts, args = Yawpa.parse(params, options, posix_order: true)
+      opts[:one].should be_true
+      opts[:two].should be_false
+      args.should eq(['arg', '--two'])
+    end
+  end
+end

data/yawpa.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/yawpa/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Josh Holtrop"]
+  gem.email         = ["jholtrop@gmail.com"]
+  gem.description   = %q{Yet Another Way to Parse Arguments is an argument-parsing library for Ruby}
+  gem.summary       = %q{Yet Another Way to Parse Arguments}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "yawpa"
+  gem.require_paths = ["lib"]
+  gem.version       = Yawpa::VERSION
+
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: yawpa
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Josh Holtrop
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Yet Another Way to Parse Arguments is an argument-parsing library for
+  Ruby
+email:
+- jholtrop@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/yawpa.rb
+- lib/yawpa/version.rb
+- spec/spec_helper.rb
+- spec/yawpa_spec.rb
+- yawpa.gemspec
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Yet Another Way to Parse Arguments
+test_files:
+- spec/spec_helper.rb
+- spec/yawpa_spec.rb