optbind 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a75ae614f40e93666809a3bcefac9e58ed61e699
-  data.tar.gz: d3a138e3f55237c587aa1d1901f529c3415afa7a
+  metadata.gz: 460ca3303bb62d3d9082fad5a691d3c96d0c68a7
+  data.tar.gz: 279ef0028459cb0b10e90f4b25421d5894cb19eb
 SHA512:
-  metadata.gz: c487f3899ff91d0a18a25647ffe10ae32dcf2cc0bf3b88aa524bb993bea749b271623b3be965970e56169bf5bd87afcc384bbf67c7f3b2b31be59bf64d45eff0
-  data.tar.gz: 2f52caa014b1fb9b66a228e1c557ba3daef0b3d220a392671880a46207fbcc71675e8184d34e2a25a7f88384e0faf88e5109baf6d4f0f584c2e7655ea026f31f
+  metadata.gz: f0ea5b17c67992e22e74486b4260536d4e298e9fff683e3c367eb718a91ff78f01f3aa19c9c1f4f038d1af58cfa7d34dece47467d467a946a4e404cd603255fd
+  data.tar.gz: d42a36c32091092fce179c4d480714e58f14ec45143a3ffd10dc86a4490b450ffdd0a5650ff01e07191dea701c6d13c11e95c8db82750ddb0b598d7db122c0c2

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 0.4.0
+
+*   Support binding options to class variables
+
+*   Support argument patterns and types, make argument processing in fact same as option processing 
+
+*   Enable setting program name via constant and set both program name and version for both default and supplied parsers
+
+*   Enable non-destructive parsing for ARGV
+
+*   Raise an error on parsing failure instead of totally aborting execution 
+
+*   Remove `order` and `permute` methods
+
+*   Conform to Ruby 2.3 and frozen strings 
+
+    *Pavol Zbell*
+
 ## 0.3.2
 
 *   Fix handling of blanks as array arguments 

data/README.md

@@ -3,12 +3,12 @@
 [![Build Status](https://img.shields.io/travis/pavolzbell/optbind.svg)](https://travis-ci.org/pavolzbell/optbind)
 [![Gem Version](https://img.shields.io/gem/v/optbind.svg)](https://rubygems.org/gems/optbind)
 
-Binds command-line options to variables.
+Binds command-line options to objects or variables.
 
 Extends command-line option analysis by wrapping an instance of standard [`OptionParser`](http://ruby-doc.org/stdlib-2.3.1/libdoc/optparse/rdoc/OptionParser.html).
-Enables binding of options and arguments to instance or local variables. Provides `Hash` and `String` only interfaces
-to define command line options, unlike a mixed interface by standard library. Supports access to default values and
-partial argument analysis. Builds Git-like options and help by default. 
+Enables binding of options and arguments to `Hash` entries, public accessors, local, instance, or class variables. Provides `Hash` and `String` only interfaces
+to define command-line options, unlike a mixed interface by standard library. Supports access to default values and argument analysis. Builds Git-like options
+and help by default. 
 
 ## Installation
 
@@ -62,11 +62,47 @@ Note that plain `OptionBinder.new` binds to local variables of top level binding
 
 See specs for more examples and details on usage.
 
+### Definitions
+
+Option and argument definitions include:
+
+#### Hash options
+
+```ruby
+e, t, v, b, m = false, 80, true, 'master', [STDIN]
+
+OptionBinder.new do |b|
+  b.usage %w([<options>] <branch> [<path>...])
+  b.usage %w([<options>] -e <branch> [<command>...])
+  b.option variable: :e, names: %w(e eval)
+  b.option variable: :t, mode: :OPTIONAL, short: 't', long: 'trim', argument: '[=<length>]', type: Integer
+  b.option variable: :v, names: %w(-v --[no]-verbose), description: 'Be more verbose.'
+  b.argument variable: :b, mode: :REQUIRED, argument: '<branch>'
+  b.argument variable: :a, mode: :OPTIONAL, multiple: true, argument: '[<mix>...]'
+end
+```
+
+#### Plain strings
+
+```ruby
+e, t, v, b, m = false, 80, true, 'master', [STDIN]
+
+OptionBinder.new do |b|
+  b.usage '[<options>] <branch> [<path>...]'
+  b.usage '[<options>] -e <branch> [<command>...]'
+  b.option 'e -e --eval'
+  b.option 't -t --trim[=<length:integer>]'
+  b.option 'v -v --[no-]verbose Be more verbose.'
+  b.argument 'b <branch>'
+  b.argument 'm [<mix>...]'
+end
+```
+
 ### Bindings
 
 Various binding possibilities include:   
 
-#### Bind to `Hash` object
+#### Bind to `Hash` entries
 
 Create target:
 
@@ -77,7 +113,7 @@ options = { input: STDIN, output: STDOUT }
 Use `OptionBinder` directly:
 
 ```ruby
-OptionBinder.new(target: options) do
+OptionBinder.new(target: options) do |b|
   # ...
 end
 ```
@@ -107,7 +143,7 @@ end
 Use `OptionBinder` directly:
 
 ```ruby
-OptionBinder.new(target: options) do
+OptionBinder.new(target: options) do |b|
   # ...
 end
 ```
@@ -135,7 +171,7 @@ options = Options.new
 Use `OptionBinder` directly:
 
 ```ruby
-OptionBinder.new(target: options, bind: :to_class_variables) do
+OptionBinder.new(target: options, bind: :to_class_variables) do |b|
   # ...
 end
 ```
@@ -165,7 +201,7 @@ options = Options.new
 Use `OptionBinder` directly:
 
 ```ruby
-OptionBinder.new(target: options, bind: :to_instance_variables) do
+OptionBinder.new(target: options, bind: :to_instance_variables) do |b|
   # ...
 end
 ```
@@ -189,7 +225,7 @@ input, output = STDIN, STDOUT
 Use `OptionBinder` directly:
 
 ```ruby
-OptionBinder.new(target: TOPLEVEL_BINDING, bind: :to_local_variables) do
+OptionBinder.new(target: TOPLEVEL_BINDING, bind: :to_local_variables) do |b|
   # ...
 end
 ```
@@ -197,7 +233,7 @@ end
 Use `OptionBinder` directly with top level binding object as target by default:
 
 ```ruby
-OptionBinder.new do
+OptionBinder.new do |b|
   # ...
 end
 ```
@@ -218,6 +254,58 @@ ARGV.define_and_bind(to: :locals) do
 end  
 ```
 
+### Extensions
+
+Several available extensions include: 
+
+#### Default
+
+Adds default values to option descriptions.
+
+```ruby
+require 'optbind/default'
+
+
+```
+
+#### Mode
+
+Adds `order` and `permute` methods.
+
+```ruby
+require 'optbind/mode'
+
+ARGV.order
+```
+
+Note that `order!` and `permute!` methods in `ARGV` from `OptionParser` are redefined to raise an unsupported error without this extension.
+
+#### Type
+
+Adds various common types to accept in definitions.
+
+```ruby
+require 'optbind/type'
+
+...
+
+binder.option 'm --matcher=<pattern:Regexp>'
+binder.option 'r --repository=<uri:URI>'
+```
+
+#### Handler
+
+Adds various common handlers to accept in definitions.
+
+```ruby
+require 'optbind/handler'
+
+... 
+
+binder.option 's --storage=<name>', &included_in(%w(file memory))
+binder.option 'a --attachments=<ids>', &listed_as(Integer)
+```
+
 ## Testing
 
     bundle exec rspec

data/TODO.md

@@ -1,15 +1,13 @@
 # TODOS
 
-  - move order and permute to separate package, required on demand
-  
-  - `Switch#parser_opts_from_string` - support regexps with options, like `=<name:/[a-z]/i>`
-  - `Switch#parser_opts_from_string` - support ranges, like `=<indent:0..8>`
-  
-  - add custom type definitions to separate package, required on demand 
+  - test against special cases for multiple args like 'a <ids...>' with '--x 1'
+  - add optbind/defaults from extise as separate package, required on demand
+
+  - add support for arrays of int -> <x:Array:Integer> and <x:Integer>... 
   - add support for ranges on `OptionParser` level
 
-  - add optbind/handlers from extise as separate package, required on demand
-  - add optbind/defaults from extise as separate package, required on demand
+  - `Switch#parser_opts_from_string` - support regexps with options, like `=<name:/[a-z]/i>`
+  - `Switch#parser_opts_from_string` - support ranges, like `=<indent:0..8>`
 
   - make optional extensions for `OptionParser` monkey-patching `make_switch` to support hash-or-string-exclusive arguments 
 

data/lib/optbind/default.rb

@@ -0,0 +1,5 @@
+module OptionBinder::Default
+  # TODO
+end
+
+OptionBinder.prepend OptionBinder::Default

data/lib/optbind/handler.rb

@@ -0,0 +1,29 @@
+module OptionBinder::Handler
+  def matched_by(p)
+    -> (v) { p =~ v.to_s ? v : raise(OptionParser::InvalidArgument, v) if v }
+  end
+
+  alias_method :matches, :matched_by
+
+  def included_in(*a)
+    -> (v) { a[0].include? v ? v : raise(OptionParser::InvalidArgument, v) if v } if a[0].is_a? Range
+    -> (v) { a.flatten.include?(v) ? v : raise(OptionParser::InvalidArgument, v) if v }
+  end
+
+  alias_method :in, :included_in
+
+  def listed_as(t)
+    -> (v) do
+      begin
+        b, p = nil, OptionParser.new.on(:REQUIRED, '--0', t, &-> (i) { b = i })
+        (v.is_a?(Array) ? v : v.to_s.split(/,/)).map { |i| p.parse! %W(--0=#{i}) and b } if v
+      rescue OptionParser::InvalidArgument
+        raise $!.tap { |e| e.args[0] = e.args[0].sub(/\A--\d+=/, '') }
+      end
+    end
+  end
+
+  alias_method :lists, :listed_as
+end
+
+OptionBinder.prepend OptionBinder::Handler

data/lib/optbind/mode.rb

@@ -0,0 +1,37 @@
+require 'optbind'
+
+class OptionBinder
+  def order(*argv, &blk)
+    order! argv.dup.flatten, &blk
+  end
+
+  def order!(argv = parser.default_argv, &blk)
+    parse_args! @parser.order! argv, &blk
+  end
+
+  def permute(*argv)
+    permute! argv.dup.flatten
+  end
+
+  def permute!(argv = parser.default_argv)
+    parse_args! @parser.permute! argv
+  end
+
+  module Arguable
+    def order(&blk)
+      binder.order self, &blk
+    end
+
+    def order!(&blk)
+      binder.order! self, &blk
+    end
+
+    def permute
+      binder.permute self
+    end
+
+    def permute!
+      binder.permute! self
+    end
+  end
+end

data/lib/optbind/type.rb

@@ -0,0 +1,102 @@
+require 'forwardable'
+
+require 'optparse/date'
+require 'optparse/shellwords'
+require 'optparse/time'
+require 'optparse/uri'
+
+class OptionBinder
+  class << self
+    extend Forwardable
+
+    def_delegators OptionParser, :accept, :reject
+  end
+
+  accept(Symbol, /.+/m) { |s, _| s.to_sym if s }
+
+  # NOTE: Regexp defined in OptionParser does not handle missing argument,
+  # therefore it is redefined to work properly on switches with optional argument
+
+  accept Regexp, %r"\A/((?:\\.|[^\\])*)/([[:alpha:]]+)?\z|.*" do |s, p, o|
+    f, k = 0, nil
+    if o
+      f |= Regexp::IGNORECASE if /i/ =~ o
+      f |= Regexp::MULTILINE if /m/ =~ o
+      f |= Regexp::EXTENDED if /x/ =~ o
+      k = o.delete 'imx'
+      k = nil if k.empty?
+    end
+    Regexp.new p || s, f, k if p || s
+  end
+
+  include OptionParser::Acceptables
+
+  # NOTE: OctalInteger defined in OptionParser does not handle 0o prefix, therefore
+  # it is redefined along with Integer and Numeric patterns which use it internally
+
+  # NOTE: OctalInteger defined in OptionParser for some reason accepts binary and hexadecimal values too,
+  # whereas DecimalInteger only accepts decimal values, therefore the OctalInteger is redefined to accept
+  # octal values only to unify its behavior with binary, decimal, and hexadecimal integer patterns
+
+  binary = '(?:0b)?[01]+(?:_[01]+)*'
+  octal = '(?:0o?)?[0-7]+(?:_[0-7]+)*'
+  decimal = '\d+(?:_\d+)*'
+  hexadecimal = '(?:0x)?[\da-f]+(?:_[\da-f]+)*'
+
+  BinaryInteger = /\A[-+]?#{binary}\z/io
+  OctalInteger = /\A[-+]?#{octal}\z/io
+  HexadecimalInteger = /\A[-+]?#{hexadecimal}\z/io
+
+  accept Integer, /\A[-+]?(?:#{binary}|#{octal}|#{hexadecimal}|#{decimal})\z/io do |*a|
+    s = a[0]
+    begin
+      Integer s
+    rescue ArgumentError
+      raise OptionParser::InvalidArgument, s
+    end if s
+  end
+
+  with_base = -> (b) do
+    -> (*a) do
+      s = a[0]
+      begin
+        Integer s, b
+      rescue ArgumentError
+        raise OptionParser::InvalidArgument, s
+      end if s
+    end
+  end
+
+  accept BinaryInteger, BinaryInteger, &with_base.call(2)
+  accept OctalInteger, OctalInteger, &with_base.call(8)
+  accept DecimalInteger, DecimalInteger, &with_base.call(10)
+  accept HexadecimalInteger, HexadecimalInteger, &with_base.call(16)
+
+  float = "(?:#{decimal}(?:\\.(?:#{decimal})?)?|\\.#{decimal})(?:E[-+]?#{decimal})?"
+  real = "[-+]?(?:#{binary}|#{octal}|#{hexadecimal}|#{float})"
+
+  accept Numeric, /\A(#{real})(?:\/(#{real}))?\z/io do |s, d, n|
+    if n
+      Rational d, n
+    elsif s
+      eval s
+    end
+  end
+
+  # NOTE: ShellWords defined in OptionParser does not handle missing argument,
+  # therefore it is redefined to work properly on switches with optional argument
+
+  ShellWords = Shellwords
+
+  OptionParser.accept(Shellwords) { |s, *| Shellwords.shellsplit s if s }
+
+  # NOTE: URI defined in OptionParser parses successfully on an empty argument,
+  # therefore it is redefined to work similarly with other complex object types
+
+  OptionParser.accept(URI) do |s, *|
+    if s
+      raise OptionParser::InvalidArgument, s if s.empty?
+      URI.parse s
+    end
+  end
+end

data/lib/optbind/version.rb

@@ -1,3 +1,3 @@
-module OptBind
-  VERSION = '0.4.0'
+class OptBind
+  VERSION = '0.5.0'
 end

data/lib/optbind.rb

@@ -45,24 +45,23 @@ class OptionBinder
 
   def_delegators :@parser, :accept, :reject
   def_delegators :@parser, :abort, :warn
-  def_delegators :@parser, :load
+  def_delegators :@parser, :environment, :load
+  def_delegators :@parser, :to_a, :to_s
 
-  def parse(argv)
-    parse!(argv.dup) and argv
+  def parse(*argv)
+    parse! argv.dup.flatten
   end
 
-  def parse!(argv)
+  def parse!(argv = parser.default_argv)
     parse_args! @parser.parse! argv
   end
 
-  def_delegators :@parser, :to_a, :to_s
-
   def_delegator :@parser, :program_name, :program
   def_delegator :@parser, :version
   def_delegator :@parser, :help
 
   def usage(*args)
-    line = (args * ' ') << "\n"
+    line = (args.flatten * ' ') << "\n"
 
     if @parser.banner =~ /\Ausage:.+\n\n/i
       @parser.banner = "usage: #{program} #{line}"
@@ -78,10 +77,11 @@ class OptionBinder
 
   def option(*opts, &handler)
     opts, handler, bound, variable, default = *several_variants(*opts, &handler)
+    o, h = *loot!(opts, &handler)
 
-    @parser.on(*opts) do |r|
+    @parser.on(*o) do |r|
       raise OptionParser::InvalidArgument if opts.include?(:REQUIRED) && (r.nil? || r.respond_to?(:empty?) && r.empty?)
-      handle! handler, r, bound, variable, default
+      handle! h, r, bound, variable, default
     end
 
     (@option_definitions ||= []) << { opts: opts, handler: handler, bound: bound, variable: variable }
@@ -93,10 +93,11 @@ class OptionBinder
 
   def argument(*opts, &handler)
     opts, handler, bound, variable, default = *several_variants(*opts, &handler)
+    o, h = *loot!(opts, &handler)
 
-    (@argument_parser ||= OptionParser.new).on(*(opts << "--#{(@argument_definitions || []).size}")) do |r|
+    (@argument_parser ||= OptionParser.new).on(*(o + ["--#{(@argument_definitions || []).size}"])) do |r|
       raise OptionParser::InvalidArgument if opts.include?(:REQUIRED) && (r.nil? || r.respond_to?(:empty?) && r.empty?)
-      handle! handler, r, bound, variable, default
+      handle! h, r, bound, variable, default
     end
 
     (@argument_definitions ||= []) << { opts: opts, handler: handler, bound: bound, variable: variable }
@@ -137,11 +138,8 @@ class OptionBinder
 
   module Switch
     def self.parser_opts_from_hash(hash = {}, &handler)
-      style = case (hash[:style] || hash[:mode]).to_s.downcase
-      when 'required' then :REQUIRED
-      when 'optional' then :OPTIONAL
-      end
-
+      p = (hash[:style] || hash[:mode]).to_s.upcase
+      style = [(p.to_sym if %w(REQUIRED OPTIONAL).include? p), (:MULTIPLE if hash[:multiple])]
       pattern = hash[:pattern] || hash[:type]
       values = hash[:values]
       names = [hash[:long], hash[:longs]].flatten.map { |n| n.to_s.sub(/\A-{,2}/, '--') if n }
@@ -156,7 +154,7 @@ class OptionBinder
       argument = (hash[:argument].to_s.sub(/\A(\[)?=?/, '=\1') if hash[:argument])
       description = ([hash[:description]].flatten * ' ' if hash[:description])
       handler ||= hash[:handler]
-      return ([style, pattern, values] + names + [argument, description]).compact, handler
+      return (style + [pattern, values] + names + [argument, description]).compact, handler
     end
 
     def self.parser_opts_from_string(string = '', &handler)
@@ -166,27 +164,27 @@ class OptionBinder
         shorts << $~[:short]
       end
 
-      style, pattern, values, argument = nil
+      style, pattern, values, argument = [], nil
 
       while string.sub!(/\A(?:(?<long>--[\[\]\-\w]+[\]\w]+)?(?:(?<argument>(?:\[?=?|=\[)[<(]\S+[)>]\.{,3}\]?)|\s+))/, '')
         longs << $~[:long] if $~[:long]
         next unless $~[:argument]
         argument = $~[:argument]
-        style = argument =~ /\A=?[<(]/ ? :REQUIRED : :OPTIONAL
-        pattern = Array if argument =~ /\.{3}\]?\z/
+        style = [argument =~ /\A=?[<(]/ ? :REQUIRED : :OPTIONAL, argument =~ /\.{3}\]?\z/ ? :MULTIPLE : nil]
         values = $~[:values].split('|') if argument =~ /(?:\[?=?|=\[)\((?<values>\S*)\)\]?/
 
         if values.nil? && argument =~ /(?:\[?=?|=\[)<(?<name>\S+):(?<pattern>\S+)>\]?/
-          pattern = Module.const_get($~[:pattern]) rescue Regexp.new($~[:pattern])
-          argument = "=<#{$~[:name]}>"
-          argument = "=[#{argument[1..-1]}]" if style == :OPTIONAL
+          argument, pattern = "=<#{$~[:name]}>#{'...' if style.include? :MULTIPLE}", $~[:pattern]
+          argument = "=[#{argument[1..-1]}]" if style.include? :OPTIONAL
+          pattern = pattern.gsub(/\//, '::').gsub(/(?:\A|[-_]+)\w/) { |p| p[-1].upcase } if pattern =~ /\A[-_a-z]/
+          pattern = OptionBinder.const_get(pattern) rescue Regexp.new(pattern)
         else
-          argument.sub!(/\A(?:=\[|\[?=?)/, style == :OPTIONAL ? '=[' : '=')
+          argument.sub!(/\A(?:=\[|\[?=?)/, style.include?(:OPTIONAL) ? '=[' : '=')
         end
       end
 
       description = !string.empty? ? string.strip : nil
-      return ([style, pattern, values] + shorts + longs + [argument, description]).compact, handler
+      return (style + [pattern, values] + shorts + longs + [argument, description]).compact, handler
     end
   end
 
@@ -196,8 +194,9 @@ class OptionBinder
     if opts.size == 1
       case opts[0]
       when Hash
-        hash, variable = opts[0], [hash.delete(:variable), hash.delete(:bind)].compact[0]
-        bound = !(opts[:bound] === false) && !!variable
+        hash = opts[0].dup
+        variable = hash.delete(:variable) || hash.delete(:bind)
+        bound = !(opts.delete(:bound) === false) && !!variable
         default = hash.delete(:default) || (@reader.call(variable.to_sym) if variable)
         opts, handler = Switch.parser_opts_from_hash hash, &handler
       when String
@@ -227,12 +226,13 @@ class OptionBinder
 
   def parse_args!(argv)
     return argv unless @argument_parser
-    k = @argument_definitions.find_index { |a| a[:opts].include? Array }
+    k = @argument_definitions.find_index { |a| a[:opts].include? :MULTIPLE }
     p = k ? argv[0...k].map { |r| [r] } << argv[k..-1] : argv.map { |r| [r] }
     p = (p.empty? ? p << [] : p).each_with_index.map do |r, i|
       a = @argument_definitions[i]
       raise TooManyArguments unless a
       raise MissingArguments if a[:opts].include?(:REQUIRED) && r.empty?
+      # TODO test escapes!
       "--#{i}=#{r * ','}" if a[:opts].include?(:REQUIRED) || !(r.empty? || r.find(&:empty?))
     end
     @argument_parser.order! p
@@ -244,6 +244,16 @@ class OptionBinder
 
   private :parse_args!
 
+  def loot!(opts, &handler)
+    return opts, handler unless opts.include? :MULTIPLE
+    o = opts.dup
+    t = o.delete o.find { |a| a != Array && a.is_a?(Module) }
+    o << Array unless o.include? Array
+    return o, handler unless t
+    require 'optbind/handler'
+    return o, -> (a) { (handler || -> (r) { r }).call listed_as(t).call a }
+  end
+
   def handle!(handler, raw, bound, variable, default)
     (handler || -> (r) { r }).call(raw == nil ? default : raw).tap do |x|
       return x unless bound
@@ -252,16 +262,16 @@ class OptionBinder
     end
   end
 
-  private :handle!
+  private :loot!, :handle!
 
   module Arguable
+    def self.extend_object(o)
+      super and return unless o.singleton_class.included_modules.include? OptionParser::Arguable
+      %i(order! permute!).each { |m| o.define_singleton_method(m) { raise 'unsupported' }}
+    end
+
     def binder=(bind)
-      unless @optbind = bind
-        class << self
-          undef_method(:binder)
-          undef_method(:binder=)
-        end
-      end
+      @optbind = bind
     end
 
     def binder(opts = {}, &blk)
@@ -276,11 +286,16 @@ class OptionBinder
         @optbind = OptionBinder.new parser: opts[:parser], target: target, bind: bind
       end
 
+      @optbind.parser.default_argv = self
       @optbind.instance_eval &blk if blk
-      self.options = @optbind.parser
+      self.options = @optbind.parser if respond_to? :options=
       @optbind
     end
 
+    extend Forwardable
+
+    def_delegators :binder, :parser, :target
+
     alias_method :define, :binder
     alias_method :define_and_bind, :binder
     alias_method :bind, :binder
@@ -297,10 +312,6 @@ class OptionBinder
 
     alias_method :bind_and_parse!, :define_and_parse!
 
-    def parser
-      self.options
-    end
-
     def parse
       binder.parse self
     end
@@ -314,3 +325,5 @@ end
 ARGV.extend(OptionBinder::Arguable)
 
 OptBind = OptionBinder
+
+require 'optbind/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optbind
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Pavol Zbell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-23 00:00:00.000000000 Z
+date: 2016-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,8 +38,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.10.0
-description: Binds command-line options to variables. Supports binding of options
-  and arguments, default values, and partial argument analysis.
+description: Binds command-line options to objects or variables. Supports binding
+  of options and arguments, default values, and argument analysis.
 email:
 - pavol.zbell@gmail.com
 executables: []
@@ -51,6 +51,10 @@ files:
 - README.md
 - TODO.md
 - lib/optbind.rb
+- lib/optbind/default.rb
+- lib/optbind/handler.rb
+- lib/optbind/mode.rb
+- lib/optbind/type.rb
 - lib/optbind/version.rb
 homepage: https://github.com/pavolzbell/optbind
 licenses:
@@ -75,5 +79,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Binds command-line options to variables.
+summary: Binds command-line options to objects or variables.
 test_files: []