xoptparse 0.2.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed8ba0e138b8c1d6e68ca65d8e022ef51f3456647121207904074ffa8d53ac9f
-  data.tar.gz: e3ffc6e2caa748fadeb8b9a6f3129491d2997c8edf89780689bc6eac02c07489
+  metadata.gz: 0fec1922d2cc3feb99ef500264fabd725220b8cd6fc4763a65e76314a2524900
+  data.tar.gz: 8625af6499870c233f0b0f9a46be9e3b04fee65aa4d5f10172e4b0f400cd867a
 SHA512:
-  metadata.gz: f160dfefb34a43a2b9f60ec775679e810613665edba3138857836467285eb5d8ce58c664687bd823322c619ea32a8c84ddab328b7e6a432c5f784dfffdff9727
-  data.tar.gz: '0950deea41a448199bc90aa1fb65365940fee26c3e3dd994c27d62e8e5677aaaf160e2234a91e24539ae36ecbc498f17aded45674e50e694c1ce4599c45ed1d5'
+  metadata.gz: 2a6d1ccfbbbf79867f826c18b8548b786dd3792d02c30d317685931716ee204175e28f6b1e31bd7fbaa959d226459ba78153212ca56aea0cd91644d312e85d29
+  data.tar.gz: 292a0fa1c8e5e62c0809ae1df4fab5bd865d0b0921d513c2bcac94dfdbcbc6acd35838bd605df2e261674c0b9cd571f2f83a0044b01a0e551764420c6e1028ef

data/.rubocop.yml

@@ -12,6 +12,9 @@ Metrics/AbcSize:
   Exclude:
     - test/**/*
 
+Metrics/BlockLength:
+  Enabled: false
+
 Metrics/ClassLength:
   Enabled: false
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    xoptparse (0.2.0)
+    xoptparse (0.6.2)
 
 GEM
   remote: https://rubygems.org/
@@ -52,7 +52,7 @@ DEPENDENCIES
   minitest-power_assert
   minitest-reporters
   rake (~> 12.3.3)
-  rubocop (= 0.84.0)
+  rubocop
   simplecov
   xoptparse!
 

data/lib/xoptparse.rb

@@ -55,130 +55,201 @@ class XOptionParser < ::OptionParser
   end
   private :search_arg_switch_atype
 
-  def fix_arg_switch(sw0)
-    pattern, conv = search_arg_switch_atype(sw0)
-    Switch::SimpleArgument.new(pattern, conv, nil, nil, sw0.desc[0], sw0.desc[1..], sw0.block)
+  def fix_arg_switch(sw0) # rubocop:disable Metrics/AbcSize
+    if !(sw0.short || sw0.long)
+      pattern, conv = search_arg_switch_atype(sw0)
+      Switch::SimpleArgument.new(pattern, conv, nil, nil, sw0.desc[0], sw0.desc[1..], sw0.block)
+    elsif sw0.is_a?(Switch::PlacedArgument) && sw0.long.size == 1 && /^--\[no-\]/ =~ sw0.long.first
+      args = [sw0.pattern, sw0.conv, sw0.short, sw0.long, sw0.arg, sw0.desc, sw0.block]
+      Switch::FlagArgument.new(*args)
+    else
+      sw0
+    end
   end
   private :fix_arg_switch
 
   def make_switch(opts, block = nil)
     sw = super(opts, block || proc {})
-    sw0 = sw[0]
+    sw0 = sw[0] = fix_arg_switch(sw[0])
     return sw if sw0.short || sw0.long
 
-    sw0 = fix_arg_switch(sw0)
-    long = sw0.arg.scan(/(?:\[\s*(.*?)\s*\]|(\S+))/).flatten.compact
+    long = sw0.arg_parameters.map(&:first)
     [sw0, nil, long]
   end
 
-  def parse_arguments(argv) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    arg_sws = select { |sw| sw.is_a?(Switch::SimpleArgument) }
+  def parse_arguments(argv, setter = nil, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    arg_sws = select { |sw| sw.is_a?(Switch::SummarizeArgument) && !opts.include?(sw.switch_name) }
     return argv if arg_sws.empty?
 
     sws_ranges = arg_sws.map(&:ranges).flatten(1)
     req_count = sws_ranges.sum(&:begin)
-    raise MissingArgument, argv.join(' ') if argv.size < req_count
-
     opt_count = sws_ranges.sum(&:size) - sws_ranges.size
     opt_index = argv[req_count...].index { |arg| @commands.include?(arg) } unless @commands.empty?
     opt_count = [opt_count, opt_index || Float::INFINITY, argv.size - req_count].min
 
-    arg_sws.each do |sw|
-      conv = proc { |v| sw.send(:conv_arg, *sw.send(:parse_arg, v))[2] }
-      a = sw.ranges.map do |r|
-        if r.end.nil?
-          rest_size = r.begin + opt_count
-          req_count -= r.begin
-          opt_count = 0
-          argv.slice!(0...rest_size).map(&conv)
-        elsif r.begin.zero?
-          next conv.call(nil) if opt_count.zero?
-
-          opt_count -= 1
-          conv.call(argv.shift)
-        else
-          req_count -= 1
-          conv.call(argv.shift)
+    arg_sws.each_with_index do |sw, i|
+      if sw.is_a?(Switch::SimpleArgument)
+        callable = false
+        conv = proc do |v|
+          callable = true
+          sw.send(:conv_arg, *sw.send(:parse_arg, v))[2]
+        end
+        a = sw.ranges.map do |r|
+          raise MissingArgument if r.begin.positive? && argv.empty?
+
+          if r.end.nil?
+            rest_size = r.begin + opt_count
+            req_count -= r.begin
+            opt_count = 0
+            argv.slice!(0...rest_size).map(&conv)
+          elsif r.begin.positive?
+            req_count -= 1
+            conv.call(argv.shift)
+          elsif opt_count.positive?
+            opt_count -= 1
+            conv.call(argv.shift)
+          end
         end
+        if callable
+          val = sw.block.call(*a)
+          setter&.call(sw.switch_name, val)
+        end
+      elsif sw.pattern =~ argv.first
+        argv.shift
+        @command_switch = sw
+        break
+      elsif !argv.empty? && i == arg_sws.size - 1
+        raise MissingArgument
       end
-      sw.block.call(*a)
     end
 
     argv
   end
   private :parse_arguments
 
-  def parse_in_order(*args, &nonopt)
-    argv = []
+  def parse_in_order(argv = default_argv, setter = nil, &nonopt)
+    nonopts = []
+    opts = {}
+    opts_setter = proc do |name, val|
+      opts[name] = true
+      setter&.call(name, val)
+    end
     rest = if nonopt
-             super(*args, &argv.method(:<<))
+             super(argv, opts_setter, &nonopts.method(:<<))
            else
-             argv = super(*args)
+             nonopts = super(argv, opts_setter)
            end
-    parse_arguments(argv).map(&nonopt)
+    parse_arguments(nonopts, setter, opts).map(&nonopt)
     rest
   end
   private :parse_in_order
 
-  def order!(*args, **kwargs)
-    return super(*args, **kwargs) if @commands.empty?
-
-    argv = super(*args, **kwargs, &nil)
-    return argv if argv.empty?
+  def order!(*args, into: nil, **kwargs)
+    return super(*args, into: into, **kwargs) if @commands.empty?
 
-    name = argv.shift
-    sw = @commands[name]
-    return sw.block.call.send(block_given? ? :permute! : :order!, *args, **kwargs) if sw
+    @command_switch = nil
+    argv = super(*args, into: into, **kwargs, &nil)
+    return argv unless @command_switch
 
-    puts "#{program_name}:" \
-         "'#{name}' is not a #{program_name} command. See '#{program_name} --help'."
-    exit
+    into = into[@command_switch.arg.to_sym] = {} if into
+    @command_switch.block.call.send(block_given? ? :permute! : :order!, *args, into: into, **kwargs)
   end
 
   def command(name, desc = nil, *args, &block)
-    sw0 = Switch::SummarizeArgument.new(nil, nil, nil, nil, name.to_s, desc ? [desc] : [], nil) do
+    name = name.to_s
+    pattern = /^#{name.gsub('_', '[-_]?')}$/i
+    sw0 = Switch::SummarizeArgument.new(pattern, nil, nil, nil, name, desc ? [desc] : [], nil) do
       self.class.new(desc, *args) do |opt|
         opt.program_name = "#{program_name} #{name}"
         block&.call(opt)
       end
     end
     top.append(sw0, nil, [sw0.arg])
-    @commands[name.to_s] = sw0
+    @commands[name] = sw0
     nil
   end
 
   class Switch < ::OptionParser::Switch
-    class SummarizeArgument < NoArgument
+    class SummarizeArgument < self
       undef_method :add_banner
 
-      def summarize(*args)
+      attr_reader :ranges
+      attr_reader :arg_parameters
+
+      def initialize(*)
+        super
+        @ranges = []
+        @arg_parameters = arg.scan(/\[\s*(.*?)\s*\]|(\S+)/).map do |opt, req|
+          name = opt || req
+          [name.sub(/\s*\.\.\.$/, ''), opt ? :opt : :req, name.end_with?('...') ? :rest : nil]
+        end
+      end
+
+      def summarize(*)
         original_arg = arg
-        @short = arg.scan(/\[\s*.*?\s*\]|\S+/)
+        @short = arg_parameters.map do |name, type, rest|
+          var = "#{name}#{rest ? '...' : ''}"
+          type == :req ? var : "[#{var}]"
+        end
         @arg = nil
-        res = super(*args)
+        res = super
         @arg = original_arg
         @short = nil
         res
       end
 
-      def match_nonswitch?(*args)
-        super(*args) if @pattern.is_a?(Regexp)
+      def match_nonswitch?(*)
+        nil
+      end
+
+      def switch_name
+        arg_parameters.first.first
+      end
+
+      def parse(_arg, _argv)
+        raise XOptionParser::InvalidOption
       end
     end
 
     class SimpleArgument < SummarizeArgument
-      attr_reader :ranges
-
-      def initialize(*args)
-        super(*args)
-        @ranges = arg.scan(/\[\s*(.*?)\s*\]|(\S+)/).map do |opt, req|
-          (opt ? 0 : 1)..((opt || req).end_with?('...') ? nil : 1)
+      def initialize(*)
+        super
+        @ranges = arg_parameters.map do |_name, type, rest|
+          (type == :req ? 1 : 0)..(rest == :rest ? nil : 1)
         end
       end
 
       def add_banner(to)
         to << " #{arg}"
       end
+
+      def parse(arg, argv) # rubocop:disable Metrics/CyclomaticComplexity
+        case ranges.size
+        when 0
+          yield(NeedlessArgument, arg) if arg
+          conv_arg(arg)
+        when 1
+          unless arg
+            raise XOptionParser::MissingArgument if argv.empty?
+
+            arg = argv.shift
+          end
+          arg = [arg] if ranges.first.end.nil?
+          conv_arg(*parse_arg(arg, &method(:raise)))
+        else
+          super(arg, argv)
+        end
+      end
+    end
+
+    class FlagArgument < PlacedArgument
+      def parse(arg, argv, &error)
+        super(arg, argv, &error).tap do |val|
+          raise OptionParser::InvalidArgument if val[0].nil? && val[2].nil?
+        end
+      rescue OptionParser::InvalidArgument
+        conv_arg(arg)
+      end
     end
   end
 end

data/lib/xoptparse/version.rb

@@ -3,5 +3,5 @@
 require 'optparse'
 
 class XOptionParser < ::OptionParser
-  VERSION = '0.2.0'
+  VERSION = '0.6.2'
 end

data/xoptparse.gemspec

@@ -29,6 +29,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-power_assert'
   spec.add_development_dependency 'minitest-reporters'
   spec.add_development_dependency 'rake', '~> 12.3.3'
-  spec.add_development_dependency 'rubocop', '0.84.0'
+  spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'simplecov'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xoptparse
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.6.2
 platform: ruby
 authors:
 - ofk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-12 00:00:00.000000000 Z
+date: 2020-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,16 +84,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.84.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.84.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement