topt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfc4bd34d4b41a577a80ec9e4b05bb518299d366
+  data.tar.gz: f8a0af259dc4659bddf91dabf79587e6c5383544
+SHA512:
+  metadata.gz: 94c007f4b87d60f08688207a05b5aaa83ec4511adb2c47ab204212204c24a536461937b16a5f6ae82e746f711477587d59271cf05d6cc17b03bd6c13167601f2
+  data.tar.gz: 99e173354685f903170ee6a6112c4c8ca02775771f1c588f837d15b94482123eaf716619da3089db101d8db8a8b0635eb56320c1f94da8896c118af1fa234dea

data/LICENSE.md

@@ -0,0 +1,24 @@
+Substantial portions of this code were extracted from Thor, which is
+Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al.
+
+Portions of this code not extracted from Thor
+Copyright (c) 2013 Martin Emde
+
+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,51 @@
+# Topt
+
+A Thor compatible replacement for Ruby's OptionParser (optparse).
+
+Provides extended options parsing, compared to optparse, using a [Thor](https://github.com/wycats/thor) compatible option parser.
+
+## About
+
+This is still a very fresh extraction. I haven't created any specs yet, so use with caution.
+
+Open an issue if you want to use this but you're scared.
+
+## Example
+
+See the examples directory from examples.
+
+    class Command
+      extend Topt
+
+      option :verbose, type: :boolean, aliases: %w[-v], :default => false, desc: "Be noisy"
+      argument :filename
+
+      def initialize(given_args=ARGV)
+        @arguments, @options, @extras = self.class.parse_options!(given_args)
+      rescue Topt::Error => e
+        puts e.message
+        puts "Usage: command [--verbose] filename"
+        exit 1
+      end
+
+      def call
+        filename = @arguments[:filename]
+        puts "Opening file #{filename}" if @options[:verbose]
+
+        File.open(filename) do |f|
+          f.each_line do |line|
+            puts "outputting line #{line}" if @options[:verbose]
+            puts line
+          end
+        end
+
+        puts "Done" if @options[:verbose]
+      end
+    end
+
+    Command.new(ARGV).call
+
+## Credit
+
+A substantial portion of this code is extracted directly from [Thor](https://github.com/wycats/thor)
+by Yehuda Katz, José Valim, and more.

data/examples/kat

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'topt'
+
+class Kat
+  extend Topt
+
+  option :blank, type: :boolean, aliases: %w[-b],
+    desc: "Number the non-blank output lines, starting at 1."
+
+  option :number, type: :boolean, aliases: %w[-n],
+    desc: "Number the output lines, starting at 1."
+
+  # If we only wanted to accept one file, we could use this and then access it
+  # with @arguments[:filename], but we'd rather accept many files, so we'll
+  # use extras to collect extra command line args
+  #
+  # argument :filename
+
+  def initialize(given_args=ARGV)
+    @options, @arguments, @extras = self.class.parse_options!(given_args)
+  end
+
+  def call
+    if @extras.empty?
+      output $stdin
+    else
+      @extras.each do |file|
+        File.open(file) do |f|
+          output f
+        end
+      end
+    end
+  end
+
+  def output(input)
+    num = 1
+    input.each_line do |line|
+      if (@options[:number] || @options[:blank]) && !(@options[:blank] && line.strip.empty?)
+        puts "#{num.to_s.rjust(6)}\t#{line}"
+        num += 1
+      else
+        puts line
+      end
+    end
+  end
+end
+
+Kat.new(ARGV).call

data/lib/topt.rb

@@ -0,0 +1,53 @@
+require 'topt/parser'
+
+# Extend your class with this module to add Thor-like options methods.
+#
+# This currently does not do any magical method based things, so you'll
+# need to do one command per class or instantiate the parser directly.
+#
+# Instantiating directly can really make your command easy to understand,
+# since there is very little magic going on at that point.
+module Topt
+  class Error < StandardError
+  end
+
+  class UnknownArgumentError < Error
+  end
+
+  class RequiredArgumentMissingError < Error
+  end
+
+  class MalformattedArgumentError < Error
+  end
+
+  def options_parser
+    @parser ||= Parser.new
+  end
+
+  def options
+    options_parser.options
+  end
+  alias_method :method_options, :options # Thor compatibility
+
+  def option(name, options)
+    options_parser.option(name, options)
+  end
+  alias_method :method_option, :option # Thor compatibility
+
+  def arguments
+    options_parser.arguments
+  end
+
+  def argument(name, options={})
+    attr_accessor name
+    options_parser.argument(name, options)
+  end
+
+  def remove_argument(*names)
+    options_parser.remove_argument(*nname)
+  end
+
+  def parse_options!(given_args=ARGV, defaults_hash = {})
+    options_parser.parse(given_args, defaults_hash)
+  end
+end

data/lib/topt/argument.rb

@@ -0,0 +1,74 @@
+module Topt
+  class Argument #:nodoc:
+    VALID_TYPES = [ :numeric, :hash, :array, :string ]
+
+    attr_reader :name, :description, :enum, :required, :type, :default, :banner
+    alias :human_name :name
+
+    def initialize(name, options={})
+      class_name = self.class.name.split("::").last
+
+      type = options[:type]
+
+      raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
+      raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
+
+      @name        = name.to_s
+      @description = options[:desc]
+      @required    = options.key?(:required) ? options[:required] : true
+      @type        = (type || :string).to_sym
+      @default     = options[:default]
+      @banner      = options[:banner] || default_banner
+      @enum        = options[:enum]
+
+      validate! # Trigger specific validations
+    end
+
+    def usage
+      required? ? banner : "[#{banner}]"
+    end
+
+    def required?
+      required
+    end
+
+    def show_default?
+      case default
+      when Array, String, Hash
+        !default.empty?
+      else
+        default
+      end
+    end
+
+    protected
+
+      def validate!
+        if required? && !default.nil?
+          raise ArgumentError, "An argument cannot be required and have default value."
+        elsif @enum && !@enum.is_a?(Array)
+          raise ArgumentError, "An argument cannot have an enum other than an array."
+        end
+      end
+
+      def valid_type?(type)
+        self.class::VALID_TYPES.include?(type.to_sym)
+      end
+
+      def default_banner
+        case type
+        when :boolean
+          nil
+        when :string, :default
+          human_name.upcase
+        when :numeric
+          "N"
+        when :hash
+          "key:value"
+        when :array
+          "one two three"
+        end
+      end
+
+  end
+end

data/lib/topt/arguments.rb

@@ -0,0 +1,174 @@
+module Topt
+  class Arguments #:nodoc:
+    NUMERIC = /(\d*\.\d+|\d+)/
+
+    # Receives an array of args and returns two arrays, one with arguments
+    # and one with switches.
+    #
+    def self.split(args)
+      arguments = []
+
+      args.each do |item|
+        break if item =~ /^-/
+        arguments << item
+      end
+
+      return arguments, args[Range.new(arguments.size, -1)]
+    end
+
+    def self.parse(*args)
+      to_parse = args.pop
+      new(*args).parse(to_parse)
+    end
+
+    # Takes an array of Thor::Argument objects.
+    #
+    def initialize(arguments=[])
+      @assigns, @non_assigned_required = {}, []
+      @switches = arguments
+
+      arguments.each do |argument|
+        if argument.default != nil
+          @assigns[argument.human_name] = argument.default
+        elsif argument.required?
+          @non_assigned_required << argument
+        end
+      end
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      @switches.each do |argument|
+        break unless peek
+        @non_assigned_required.delete(argument)
+        @assigns[argument.human_name] = send(:"parse_#{argument.type}", argument.human_name)
+      end
+
+      check_requirement!
+
+      assigns = Topt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def remaining
+      @pile
+    end
+
+    private
+
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
+      end
+
+      def last?
+        @pile.empty?
+      end
+
+      def peek
+        @pile.first
+      end
+
+      def shift
+        @pile.shift
+      end
+
+      def unshift(arg)
+        unless arg.kind_of?(Array)
+          @pile.unshift(arg)
+        else
+          @pile = arg + @pile
+        end
+      end
+
+      def current_is_value?
+        peek && peek.to_s !~ /^-/
+      end
+
+      # Runs through the argument array getting strings that contains ":" and
+      # mark it as a hash:
+      #
+      #   [ "name:string", "age:integer" ]
+      #
+      # Becomes:
+      #
+      #   { "name" => "string", "age" => "integer" }
+      #
+      def parse_hash(name)
+        return shift if peek.is_a?(Hash)
+        hash = {}
+
+        while current_is_value? && peek.include?(?:)
+          key, value = shift.split(':',2)
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Runs through the argument array getting all strings until no string is
+      # found or a switch is found.
+      #
+      #   ["a", "b", "c"]
+      #
+      # And returns it as an array:
+      #
+      #   ["a", "b", "c"]
+      #
+      def parse_array(name)
+        return shift if peek.is_a?(Array)
+        array = []
+
+        while current_is_value?
+          array << shift
+        end
+        array
+      end
+
+      # Check if the peek is numeric format and return a Float or Integer.
+      # Otherwise raises an error.
+      #
+      def parse_numeric(name)
+        return shift if peek.is_a?(Numeric)
+
+        unless peek =~ NUMERIC && $& == peek
+          raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
+        end
+
+        $&.index('.') ? shift.to_f : shift.to_i
+      end
+
+      # Parse string:
+      # for --string-arg, just return the current value in the pile
+      # for --no-string-arg, nil
+      #
+      def parse_string(name)
+        if no_or_skip?(name)
+          nil
+        else
+          value = shift
+          if @switches.is_a?(Hash) && switch = @switches[name]
+            if switch.enum && !switch.enum.include?(value)
+              raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+            end
+          end
+          value
+        end
+      end
+
+      # Raises an error if @non_assigned_required array is not empty.
+      #
+      def check_requirement!
+        unless @non_assigned_required.empty?
+          names = @non_assigned_required.map do |o|
+            o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+          end.join("', '")
+
+          class_name = self.class.name.split('::').last.downcase
+          raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
+        end
+      end
+
+  end
+end

data/lib/topt/hash_with_indifferent_access.rb

@@ -0,0 +1,71 @@
+module Topt
+  # A hash with indifferent access and magic predicates.
+  #
+  #   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+  #
+  #   hash[:foo]  #=> 'bar'
+  #   hash['foo'] #=> 'bar'
+  #   hash.foo?   #=> true
+  #
+  class HashWithIndifferentAccess < ::Hash #:nodoc:
+
+    def initialize(hash={})
+      super()
+      hash.each do |key, value|
+        self[convert_key(key)] = value
+      end
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      other.each do |key, value|
+        self[convert_key(key)] = value
+      end
+      self
+    end
+
+    protected
+
+    def convert_key(key)
+      key.is_a?(Symbol) ? key.to_s : key
+    end
+
+    # Magic predicates. For instance:
+    #
+    #   options.force?                  # => !!options['force']
+    #   options.shebang                 # => "/usr/lib/local/ruby"
+    #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+    #
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method =~ /^(\w+)\?$/
+        if args.empty?
+          !!self[$1]
+        else
+          self[$1] == args.first
+        end
+      else
+        self[method]
+      end
+    end
+  end
+end

data/lib/topt/option.rb

@@ -0,0 +1,123 @@
+require 'topt/argument'
+
+module Topt
+  class Option < Argument #:nodoc:
+    attr_reader :aliases, :group, :lazy_default, :hide
+
+    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
+
+    def initialize(name, options={})
+      options[:required] = false unless options.key?(:required)
+      super
+      @lazy_default = options[:lazy_default]
+      @group        = options[:group].to_s.capitalize if options[:group]
+      @aliases      = Array(options[:aliases])
+      @hide         = options[:hide]
+    end
+
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    #
+    def self.parse(key, value)
+      if key.is_a?(Array)
+        name, *aliases = key
+      else
+        name, aliases = key, []
+      end
+
+      name    = name.to_s
+      default = value
+
+      type = case value
+      when Symbol
+        default = nil
+        if VALID_TYPES.include?(value)
+          value
+        elsif required = (value == :required)
+          :string
+        end
+      when TrueClass, FalseClass
+        :boolean
+      when Numeric
+        :numeric
+      when Hash, Array, String
+        value.class.name.downcase.to_sym
+      end
+      self.new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
+    end
+
+    def switch_name
+      @switch_name ||= dasherized? ? name : dasherize(name)
+    end
+
+    def human_name
+      @human_name ||= dasherized? ? undasherize(name) : name
+    end
+
+    def usage(padding=0)
+      sample = if banner && !banner.to_s.empty?
+        "#{switch_name}=#{banner}"
+      else
+        switch_name
+      end
+
+      sample = "[#{sample}]" unless required?
+
+      if aliases.empty?
+        (" " * padding) << sample
+      else
+        "#{aliases.join(', ')}, #{sample}"
+      end
+    end
+
+    VALID_TYPES.each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{type}?
+          self.type == #{type.inspect}
+        end
+      RUBY
+    end
+
+  protected
+
+    def validate!
+      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+    end
+
+    def dasherized?
+      name.index('-') == 0
+    end
+
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
+
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+    end
+  end
+end

data/lib/topt/options.rb

@@ -0,0 +1,182 @@
+require 'topt/arguments'
+require 'topt/hash_with_indifferent_access'
+
+module Topt
+  class Options < Arguments #:nodoc:
+    LONG_RE     = /^(--\w+(?:-\w+)*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+
+    # Receives a hash and makes it switches.
+    def self.to_switches(options)
+      options.map do |key, value|
+        case value
+          when true
+            "--#{key}"
+          when Array
+            "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
+          when Hash
+            "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
+          when nil, false
+            ""
+          else
+            "--#{key} #{value.inspect}"
+        end
+      end.join(" ")
+    end
+
+    # Takes a hash of Thor::Option and a hash with defaults.
+    def initialize(hash_options={}, defaults={})
+      options = hash_options.values
+      super(options)
+
+      # Add defaults
+      defaults.each do |key, value|
+        @assigns[key.to_s] = value
+        @non_assigned_required.delete(hash_options[key])
+      end
+
+      @shorts, @switches, @extra = {}, {}, []
+
+      options.each do |option|
+        @switches[option.switch_name] = option
+
+        option.aliases.each do |short|
+          name = short.to_s.sub(/^(?!\-)/, '-')
+          @shorts[name] ||= option.switch_name
+        end
+      end
+    end
+
+    def remaining
+      @extra
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      while peek
+        match, is_switch = current_is_switch?
+        shifted = shift
+
+        if is_switch
+          case shifted
+            when SHORT_SQ_RE
+              unshift($1.split('').map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+          end
+
+          switch = normalize_switch(switch)
+          option = switch_option(switch)
+          @assigns[option.human_name] = parse_peek(switch, option)
+        elsif match
+          @extra << shifted
+          @extra << shift while peek && peek !~ /^-/
+        else
+          @extra << shifted
+        end
+      end
+
+      check_requirement!
+
+      assigns = Topt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def check_unknown!
+      # an unknown option starts with - or -- and has no more --'s afterward.
+      unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
+      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
+    end
+
+    protected
+
+      # Returns true if the current value in peek is a registered switch.
+      #
+      def current_is_switch?
+        case peek
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+          [true, switch?($1)]
+        when SHORT_SQ_RE
+          [true, $1.split('').any? { |f| switch?("-#{f}") }]
+        else
+          [false, false]
+        end
+      end
+
+      def current_is_switch_formatted?
+        case peek
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+          true
+        else
+          false
+        end
+      end
+
+      def switch?(arg)
+        switch_option(normalize_switch(arg))
+      end
+
+      def switch_option(arg)
+        if match = no_or_skip?(arg)
+          @switches[arg] || @switches["--#{match}"]
+        else
+          @switches[arg]
+        end
+      end
+
+      # Check if the given argument is actually a shortcut.
+      #
+      def normalize_switch(arg)
+        (@shorts[arg] || arg).tr('_', '-')
+      end
+
+      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+      #
+      def parse_boolean(switch)
+        if current_is_value?
+          if ["true", "TRUE", "t", "T", true].include?(peek)
+            shift
+            true
+          elsif ["false", "FALSE", "f", "F", false].include?(peek)
+            shift
+            false
+          else
+            true
+          end
+        else
+          @switches.key?(switch) || !no_or_skip?(switch)
+        end
+      end
+
+      # Parse the value at the peek analyzing if it requires an input or not.
+      #
+      def parse_peek(switch, option)
+        if current_is_switch_formatted? || last?
+          if option.boolean?
+            # No problem for boolean types
+          elsif no_or_skip?(switch)
+            return nil # User set value to nil
+          elsif option.string? && !option.required?
+            # Return the default if there is one, else the human name
+            return option.lazy_default || option.default || option.human_name
+          elsif option.lazy_default
+            return option.lazy_default
+          else
+            raise MalformattedArgumentError, "No value provided for option '#{switch}'"
+          end
+        end
+
+        @non_assigned_required.delete(option)
+        send(:"parse_#{option.type}", switch)
+      end
+  end
+end

data/lib/topt/parser.rb

@@ -0,0 +1,153 @@
+require 'topt/arguments'
+require 'topt/argument'
+require 'topt/options'
+require 'topt/option'
+
+module Topt
+  class Parser
+    attr_reader :options
+    attr_reader :arguments
+
+    # Create a parser for parsing ARGV input into options.
+    #
+    def initialize
+      @options = {}
+      @arguments = []
+      yield self if block_given?
+    end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined task.
+    #
+    #   parser.option :foo => :bar
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    #
+    def option(name, opts)
+      @options[name] = Topt::Option.new(name, opts)
+    end
+
+    # Adds an argument to the class and creates an attr_accessor for it.
+    #
+    # Arguments are different from options in several aspects. The first one
+    # is how they are parsed from the command line, arguments are retrieved
+    # from position:
+    #
+    #   thor task NAME
+    #
+    # Instead of:
+    #
+    #   thor task --name=NAME
+    #
+    # Besides, arguments are used inside your code as an accessor (self.argument),
+    # while options are all kept in a hash (self.options).
+    #
+    # Finally, arguments cannot have type :default or :boolean but can be
+    # optional (supplying :optional => :true or :required => false), although
+    # you cannot have a required argument after a non-required argument. If you
+    # try it, an error is raised.
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :optional - If the argument is optional or not.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :banner   - String to show on usage notes.
+    #
+    # ==== Errors
+    # ArgumentError:: Raised if you supply a required argument after a non required one.
+    #
+    def argument(name, opts={})
+      required = if opts.key?(:optional)
+        !opts[:optional]
+      elsif opts.key?(:required)
+        opts[:required]
+      else
+        opts[:default].nil?
+      end
+
+      remove_argument name
+
+      if required
+        @arguments.each do |argument|
+          next if argument.required?
+          raise ArgumentError,
+            "You cannot have #{name.to_s.inspect} as required argument after " \
+            "the non-required argument #{argument.human_name.inspect}."
+        end
+      end
+
+      opts[:required] = required
+
+      @arguments << Topt::Argument.new(name, opts)
+    end
+
+    # Removes a previous defined argument.
+    #
+    # ==== Parameters
+    # names<Array>:: Arguments to be removed
+    #
+    # ==== Examples
+    #
+    #   parser.remove_argument :foo
+    #   parser.remove_argument :foo, :bar, :baz
+    #
+    def remove_argument(*names)
+      names.each do |name|
+        @arguments.delete_if { |a| a.name == name.to_s }
+      end
+    end
+
+    # Parse the given argv-style arguments and return options, arguments,
+    # and any remaining unnamed arguments
+    def parse(given_args=ARGV, defaults_hash = {})
+      # split inbound arguments at the first argument
+      # that looks like an option (starts with - or --).
+      argv_args, argv_switches = Topt::Options.split(given_args.dup)
+
+      # Let Thor::Options parse the options first, so it can remove
+      # declared options from the array. This will leave us with
+      # a list of arguments that weren't declared.
+      parsed_options, remaining = parse_options(argv_switches, defaults_hash)
+
+      # Add the remaining arguments from the options parser to the
+      # arguments from argv_args. Then remove any positional
+      # arguments declared using #argument. This will leave us with
+      # the remaining positional arguments.
+      to_parse = argv_args + remaining
+      parsed_arguments, parsed_remaining = parse_arguments(to_parse)
+
+      [parsed_options, parsed_arguments, parsed_remaining]
+    end
+
+    # Parse option switches array into options and remaining non-option
+    # positional arguments.
+    def parse_options(argv_switches, defaults_hash)
+      options_parser = Topt::Options.new(@options, defaults_hash)
+      [options_parser.parse(argv_switches), options_parser.remaining]
+    end
+
+    # Parse declared arguments from the given argument array, returning
+    # a hash of argument name and values, and an array of remaining args.
+    def parse_arguments(to_parse)
+      args_parser = Topt::Arguments.new(@arguments)
+      [args_parser.parse(to_parse), args_parser.remaining]
+    end
+  end
+end

data/lib/topt/version.rb

@@ -0,0 +1,3 @@
+module Topt
+  VERSION = '0.0.1'
+end

data/topt.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/topt/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.add_development_dependency 'bundler', '~> 1.0'
+  s.add_development_dependency 'fakeweb', '~> 1.3'
+  s.add_development_dependency 'rake', '~> 0.9'
+  s.add_development_dependency 'rdoc', '~> 3.9'
+  s.add_development_dependency 'rspec', '~> 2.3'
+  s.add_development_dependency 'simplecov', '~> 0.4'
+  #s.add_development_dependency 'childlabor'
+  s.authors = ['Yehuda Katz', 'José Valim', 'Martin Emde']
+  s.description = %q{Thor compatible command line option parser. A replacement for Ruby's OptionParser (optparse).}
+  s.summary = <<-SUMMARY
+A replacement for OptionParser ('optparse') and Thor that supports extended options parsing based on Thor's parsing rules.
+The goal of topt is a drop in replacement for Thor command line parsing where backwards compatibility is important.
+  SUMMARY
+  s.email = 'me@martinemde.com'
+  s.executables = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.extra_rdoc_files = ['LICENSE.md', 'README.md']
+  s.license = 'MIT'
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'https://github.com/martinemde/topt'
+  s.name = 'topt'
+  s.rdoc_options = ['--charset=UTF-8']
+  s.require_paths = ['lib']
+  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.version = Topt::VERSION
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: topt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yehuda Katz
+- José Valim
+- Martin Emde
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Thor compatible command line option parser. A replacement for Ruby's
+  OptionParser (optparse).
+email: me@martinemde.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.md
+- README.md
+files:
+- LICENSE.md
+- README.md
+- examples/kat
+- lib/topt.rb
+- lib/topt/argument.rb
+- lib/topt/arguments.rb
+- lib/topt/hash_with_indifferent_access.rb
+- lib/topt/option.rb
+- lib/topt/options.rb
+- lib/topt/parser.rb
+- lib/topt/version.rb
+- topt.gemspec
+homepage: https://github.com/martinemde/topt
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A replacement for OptionParser ('optparse') and Thor that supports extended
+  options parsing based on Thor's parsing rules. The goal of topt is a drop in replacement
+  for Thor command line parsing where backwards compatibility is important.
+test_files: []