optbind 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c395c64551b84df7175dfec28a79be4c22f8c573
-  data.tar.gz: 74866508882f4f8fdf85255742843f17d7081998
+  metadata.gz: 08d6fbf553b3406e305a2b8f2f238d322af9f940
+  data.tar.gz: 6bbb9c352093c33304bf7efd1b9e28b58f4fae89
 SHA512:
-  metadata.gz: 1e2d3ebdbad19da59c35a9662aeb3d2d30615ed00331b301857825e11e16fc54cf5603e5bc1f71615d81c37fa19c6716eb38c7736f025ab2ec13d43e4de4305d
-  data.tar.gz: 8b53927e37f120ddaad40926ef5d4d7f4d826ac17d4079481a7100a37a342f9d314794c91a327a2ee841cb94321f273692efa085fd8e6045d437b970bc28ee00
+  metadata.gz: d836778a595cb58dc5abddd17c975cc043e677250282d54071450034d75e77478361cbe43040b7d922222ee3677d679fceb2ed264598c5a01830022e4e0ea6a0
+  data.tar.gz: be2ecf0661478e19f81b3e1904bc243e264e12b5842f54b583bca126a68011bb26620177eb7fa4d42a6384f6debdec55faa600f1d180ab782c795a62ccad8578

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.0.1
+
+*   Add initial extension to standard command line option parsing, setup Gem environment and RSpec tests 
+
+    *Pavol Zbell*

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Pavol Zbell
+
+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,53 @@
+# OptBind
+
+[![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://badge.fury.io/gh/pavolzbell/optbind)
+
+Binds command-line options to variables.
+
+Extends command-line option analysis by wrapping an instance of standard [`OptionParser`](http://ruby-doc.org/stdlib-2.2.3/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. 
+
+## Installation
+
+    bundle install optbind
+
+## Usage
+
+Binds local variables to `ARGV` and parses command line arguments: 
+
+```ruby
+ARGV                                         #=> ['--no-verbose' '-o', 'file.out', 'file.in'] 
+
+i, o, v = STDIN, STDOUT, true
+
+ARGV.bind_and_parse! to: :locals do
+  use '[<options>] [<file>]'
+  use '--help'
+  opt 'o -o --output=<file>'
+  opt 'v -v --[no-]verbose'
+  arg 'i [<file>]'
+end
+
+[i, o, v]                                    #=> ['file.in', 'file.out', false]
+```
+
+See specs for more examples and details on usage.
+
+## Testing
+
+    bundle exec rspec
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin new-feature`)
+5. Create new Pull Request
+
+## License
+
+This software is released under the [MIT License](LICENSE.md)

data/TODO.md

@@ -0,0 +1,27 @@
+# TODOS
+
+  - `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 default support for ranges on `OptionParser` level
+  - add type conversion and patterns for arguments
+  - make optional extensions for `OptionParser` monkey-patching `make_switch` to support hash-or-string-exclusive arguments 
+
+# IDEAS
+
+gems:
+  optparse-struct   struct/hash-only API       #make_switch_from_struct, #make_switch_from_hash (override make_switch, add to ARGV) 
+  optparse-string   string only API            #make_switch_from_string (override make_switch, add to ARGV)
+  optparse-usage    git-like usage             #usage, #use (override to_s, use banner, use version, auto-add --help and --version, add to ARGV)
+  optbind           bindings to vars           #bind, #bind! (bind to local/instance vars, support defaults, add to ARGV)
+  opt ???           enhances syntax            see syntax def below
+  optargs           supoort for args            
+
+- store defaults and make them always accessible
+- support arguments? consider ARGF
+
+- bind API:
+  must be uninvasive, i.e. must not affect #on in any way, must act as #parse, see example
+  ARGV, OptionParser (options)
+  example: ARGV.options { |o| o.on(...); o.bind ...; o.parse! }
+  on #bind call, #bind goes through all options (objects produced by make_switch) and binds them to variables 
+  NO: ARGV.bind shortcut just ARGV.options.bind

data/lib/optbind/version.rb

@@ -0,0 +1,3 @@
+module OptBind
+  VERSION = '0.0.2'
+end

data/lib/optbind.rb

@@ -0,0 +1,297 @@
+require 'forwardable'
+require 'optparse'
+
+class OptionBinder
+  attr_reader :parser, :target
+
+  def initialize(parser: nil, target: nil, bind: nil)
+    target, bind = TOPLEVEL_BINDING, :to_local_variables if target == nil && bind == nil
+    @parser = resolve_parser(parser)
+    @target, @reader, @writer = target, *resolve_binding(target, bind)
+    yield self if block_given?
+  end
+
+  def resolve_binding(target, bind)
+    case bind
+    when :to_local_variables
+      raise ArgumentError unless target.is_a? Binding
+      return -> (v) { target.local_variable_get v }, -> (v, x) { target.local_variable_set v, x }
+    when :to_instance_variables
+      return -> (v) { target.instance_variable_get "@#{v}" }, -> (v, x) { target.instance_variable_set "@#{v}", x }
+    else
+      return -> (v) { target[v] }, -> (v, x) { target[v] = x } if target.respond_to? :[]
+      return -> (v) { target.public_send v }, -> (v, x) { target.public_send "#{v}=", x }
+    end
+  end
+
+  def resolve_parser(parser = nil)
+    parser || OptionParser.new do |p|
+      p.define_singleton_method(:banner) { (b = super()) !~ /\AU/ ? b : "usage: #{program_name}\n\n" }
+      p.define_singleton_method(:version) { super() || (defined?(::VERSION) && ::VERSION) }
+      p.define_singleton_method(:help) { super() << "    -h, --help\n        --version\n\n" }
+    end
+  end
+
+  private :resolve_binding, :resolve_parser
+
+  extend Forwardable
+
+  def_delegators :@parser, :accept, :reject
+  def_delegators :@parser, :abort, :warn
+  def_delegators :@parser, :load
+
+  def order(*argv, &blk)
+    @parser.order *argv, &blk
+    parse_args argv
+  end
+
+  def order!(argv)
+    @parser.order! argv
+    parse_args argv
+  end
+
+  def permute(*argv)
+    @parser.permute *argv
+    parse_args argv
+  end
+
+  def permute!(argv)
+    @parser.permute! argv
+    parse_args argv
+  end
+
+  def parse(*argv)
+    @parser.parse *argv
+    parse_args argv
+  end
+
+  def parse!(argv)
+    @parser.parse! argv
+    parse_args! 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"
+
+    if @parser.banner =~ /\Ausage:.+\n\n/i
+      @parser.banner = "usage: #{program} " << line
+      @parser.separator "\n"
+    else
+      @parser.banner << "   or: #{program} " << line
+    end
+
+    self
+  end
+
+  alias_method :use, :usage
+
+  def option(*opts, &handler)
+    opts, handler, bound, variable, default = *several_variants(*opts, &handler)
+
+    @parser.on(*opts) do |r|
+      unless opts.include? :OPTIONAL
+        a = opts.select { |o| o =~ /\A-/ }.sort_by { |o| o.length }[-1]
+        @parser.abort "missing argument: #{a}=" if !r || (r.respond_to?(:empty?) && r.empty?)
+      end
+
+      (handler || -> (_) { r }).call(r == nil ? default : r).tap { |x| @writer.call variable, x if bound }
+    end
+
+    (@bound_variables_with_defaults ||= {})[variable] = default if bound
+    self
+  end
+
+  alias_method :opt, :option
+
+  def argument(*opts, &handler)
+    opts, handler, bound, variable, default = *several_variants(*opts, &handler)
+
+    opts.each do |opt|
+      (opts << :MULTIPLE) and break if opt.to_s =~ /<\S+>\.{3}/
+    end
+
+    (@argument_definitions ||= []) << { opts: opts, handler: handler, bound: bound, variable: variable }
+    (@bound_variables_with_defaults ||= {})[variable] = default if bound
+    self
+  end
+
+  alias_method :arg, :argument
+
+  def bound_defaults
+    @bound_variables_with_defaults ? @bound_variables_with_defaults.dup : {}
+  end
+
+  def bound_variables
+    return {} unless @bound_variables_with_defaults
+    Hash[@bound_variables_with_defaults.keys.map { |v| [v, @reader.call(v)] }]
+  end
+
+  def default?(v)
+    v = v.to_sym
+    return nil unless (@bound_variables_with_defaults || {}).has_key? v
+    @bound_variables_with_defaults[v] == @reader.call(v)
+  end
+
+  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
+
+      pattern = hash[:pattern] || hash[:type]
+      values = hash[:values]
+
+      names = [hash[:long], hash[:longs]].flatten.map { |n| n.to_s.sub(/\A-{,2}/, '--') if n }
+      names += [hash[:short], hash[:shorts]].flatten.map { |n| n.to_s.sub(/\A-{,2}/, '-') if n }
+      names += [hash[:name], hash[:names]].flatten.map do |n|
+        next unless n
+        n = n.to_s
+        next n if n[0] == '-'
+        n[2] ? "--#{n}" : "-#{n}"
+      end
+
+      argument = (hash[:argument].to_s if hash[:argument])
+      description = ([hash[:description]].flatten * ' ' if hash[:description])
+      handler ||= hash[:handler]
+      return ([style, pattern, values] + names + [argument, description]).compact, handler
+    end
+
+    def self.parser_opts_from_string(string = '', &handler)
+      shorts, longs = [], []
+
+      while string.sub!(/\A(?:(?<short>-\w)\s+)/, '')
+        shorts << $~[:short]
+      end
+
+      style, pattern, values, argument = nil
+
+      while string.sub!(/\A(?:(?<long>--[\[\]\-\w]+[\]\w]+)?(?:(?<argument>\[?=[<(]\S+[)>]\.{,3}\]?)|\s+))/, '')
+        longs << $~[:long]
+        argument = $~[:argument]
+
+        next unless argument
+
+        style = argument[0] == '=' ? :REQUIRED : :OPTIONAL
+        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}]" if style == :OPTIONAL
+        end
+      end
+
+      description = !string.empty? ? string.strip : nil
+      return ([style, pattern, values] + shorts + longs + [argument, description]).compact, handler
+    end
+  end
+
+  def several_variants(*opts, &handler)
+    bound, variable, default = false, nil, nil
+
+    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
+        default = hash.delete(:default) || (@reader.call(variable.to_sym) if variable)
+        opts, handler = Switch.parser_opts_from_hash hash, &handler
+      when String
+        string, variable = *(opts[0] !~ /\A\s*-/ ? opts[0].split(/\s+/, 2).reverse : [opts[0], nil])
+        bound, default = !!variable, (@reader.call(variable.to_sym) if variable)
+        opts, handler = Switch.parser_opts_from_string string, &handler
+      end
+    end
+
+    variable = variable.to_sym if variable
+    return opts, handler, bound, variable, default
+  end
+
+  private :several_variants
+
+  def parse_args(argv)
+    parse_args! argv.dup
+  end
+
+  def parse_args!(argv)
+    return argv unless @argument_definitions
+    @argument_definitions.each do |a|
+      default = (@bound_variables_with_defaults ||= {})[a[:variable]]
+      r = argv[0] ? argv.shift : default
+      r = ([r] + argv.shift(argv.size)) if a[:opts].include? :MULTIPLE
+      @parser.abort 'missing arguments' if r.nil? && args[:opts].include?(:REQUIRED)
+      (a[:handler] || -> (_) { r }).call(r == nil ? default : r).tap { |x| @writer.call a[:variable], x if a[:bound] }
+      return argv if a[:opts].include? :MULTIPLE
+    end
+    @parser.abort 'too many arguments' if argv[0]
+    argv
+  end
+
+  private :parse_args, :parse_args!
+
+  module Arguable
+    def binder=(bind)
+      unless @optbind = bind
+        class << self
+          undef_method(:binder)
+          undef_method(:binder=)
+        end
+      end
+    end
+
+    def binder(opts = {}, &blk)
+      unless @optbind
+        if opts[:to] == :locals
+          target, bind = TOPLEVEL_BINDING, :to_local_variables
+        else
+          target = opts[:target] || opts[:to]
+          bind = (:to_local_variables if opts[:locals]) || opts[:bind] || ("to_#{opts[:via]}".to_sym if opts[:via])
+        end
+
+        @optbind = OptionBinder.new parser: opts[:parser], target: target, bind: bind
+      end
+
+      @optbind.instance_eval &blk if blk
+      self.options = @optbind.parser
+      @optbind
+    end
+
+    alias_method :define, :binder
+    alias_method :define_and_bind, :binder
+    alias_method :bind, :binder
+
+    def define_and_parse!(opts = {}, &blk)
+      define opts, &blk
+      parse!
+    end
+
+    alias_method :bind_and_parse!, :define_and_parse!
+
+    def parser
+      self.options
+    end
+
+    def order!(&blk)
+      binder.order! self, &blk
+    end
+
+    def permute!
+      binder.permute! self
+    end
+
+    def parse!
+      binder.parse! self
+    end
+  end
+end
+
+ARGV.extend(OptionBinder::Arguable)
+
+OptBind = OptionBinder

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optbind
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Pavol Zbell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-30 00:00:00.000000000 Z
+date: 2015-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.10.0
 description: Binds command-line options to variables. Supports binding of options
   and arguments, default values, and partial argument analysis.
 email:
@@ -73,7 +73,13 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- TODO.md
+- lib/optbind.rb
+- lib/optbind/version.rb
 homepage: https://github.com/pavolzbell/optbind
 licenses:
 - MIT
@@ -86,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="