optparse2 0.5.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b73eda58e3715e16d45898c5d4e22386a23ba2363d0708c02ea336aec51a631
-  data.tar.gz: 777192092c696ec69bd6199fbcbd09819468dc0b06541268fa8d1a1ba4b4e389
+  metadata.gz: 6f61087f5b177ee9ffd0a587eb64ba8ff08893468ac8e0920621ee77d7b4a1b6
+  data.tar.gz: e5608123d52c5ad10d460f11ceb67bc9e9b0d5b145a502f9db16255e8df9ca0d
 SHA512:
-  metadata.gz: c31c01a23b2d0b7020cc004d6a4dda0f24ed2dfe18464a5f8f71249502cedd425e4cb2bb341d4974e733b7e1e721b9f421e49ee022009780c3d512216df220fb
-  data.tar.gz: e0d55f1dc1a4743a3b7d3e763272791d30895e89fcbc60ebab3554bce3f0fa1dc3dcbd0a40cef3248875d32b8d1c9da507c773e4e41e33c02065af0439e9676f
+  metadata.gz: 1155a87469ff90eaf3734338e4b883f97077e85327b4099a83bf360dd5f63bc5f136da6c3dee8a4de1ce0c0d8f98c1f85ae180f845ed0615dee4aee98747b345
+  data.tar.gz: e7099e4a6c7e2c0021a35c3b8b95ecafd632ed63bf86f26e9aca2884c42bb749d3f03c1baab1ad3527a90fb4a5434c2540ca1ac6f1ed4ce3167e7fa4eeedcc14

data/lib/optparse2/context.rb

@@ -0,0 +1,51 @@
+class OptParse2
+  # A Context is in charge of all option parsing
+  class Context
+    class << self
+      attr_accessor :current
+
+      def with_context(...)
+        context = new(...)
+        old, self.current = current, context
+        yield context
+      ensure
+        self.current = old
+      end
+    end
+
+    attr_reader :non_options, :deferred_options, :already_parsed_options
+
+    def initialize(into:, nonopt:)
+      @into = into
+      @nonopt = nonopt
+
+      @already_parsed_options = {}
+      @non_options = []
+      @deferred_options = {}
+    end
+
+    def add_non_option(non_option)
+      @non_options << non_option
+    end
+
+    def handle_deferred!
+      @deferred_options.each do |key, deferred|
+        self[key] = deferred[:proc].call(deferred[:data]) if deferred[:proc]
+      end
+    end
+
+    def key?(key)
+      @already_parsed_options.key?(key)
+    end
+
+    # Directly assigns `value` to `key`, both in the internal list of parsed
+    # options, as well as in the `into:` option (if one is provided).
+    #
+    # Note that if `value` is `DONT_ASSIGN` nothing happens
+    def []=(key, value)
+      return if DONT_ASSIGN.equal?(value)
+      @already_parsed_options[key] = value
+      @into[key] = value if @into
+    end
+  end
+end

data/lib/optparse2/switch-helpers.rb

@@ -0,0 +1,171 @@
+class OptParse2
+  ## Helpers is a mixin that contains methods to modify how the original `Switch` works
+
+  module Helpers
+    # Mark the switch as hidden (so it won't show up in the usage)
+    def set_hidden
+      def self.summarize(*) end
+    end
+
+    # The name of the switch; this is the key that's used when assigning options into an `into:`.
+    # It normally corresponds to the flag name (`--foo-bar` -> `foo-bar`), but can be overwritten
+    # as needed.
+    attr_writer :switch_name
+    def switch_name
+      defined?(@switch_name) ? @switch_name : super
+    end
+
+    def set_multiple(multiple)
+      old_block = @block
+      sw = switch_name.to_sym
+
+      case multiple
+      in :first!
+        @block = ->(arg, **nil) do
+          ctx = OptParse2::Context.current
+          if ctx.deferred_options.key? sw
+            OptParse2::DONT_ASSIGN
+          else
+            ctx.deferred_options[sw] = {}
+            old_block ? old_block.call(arg) : arg
+          end
+        end
+      in :first
+        @block = ->(arg, **nil) do
+          ctx = OptParse2::Context.current
+          if ctx.deferred_options.key? sw
+            OptParse2::DONT_ASSIGN
+          else
+            ctx.deferred_options[sw] = {
+              proc: old_block ? proc{ old_block.call(arg) } : proc { arg }
+            }
+            OptParse2::DONT_ASSIGN
+          end
+        end
+      in :last!, nil
+        # don't do anything, this is the default behaviour
+      in :last
+        @block = ->(arg, **nil) do
+          ctx = OptParse2::Context.current
+          ctx.deferred_options[sw] = {
+            proc: old_block ? proc { old_block.call(arg) } : proc { arg }
+          }
+
+          OptParse2::DONT_ASSIGN
+        end
+      in :raise
+        @block = ->(arg) do
+          ctx = OptParse2::Context.current
+          if ctx.already_parsed_options.key? sw or ctx.deferred_options.key? sw
+            raise OptParse2::ParseError, "encountered repeated option"
+          end
+
+          old_block ? old_block.call(arg) : arg
+        end
+
+      in :count
+        @block = ->(amnt, **nil) do
+          ctx = OptParse2::Context.current
+
+          ctx.deferred_options[sw] ||= {
+            proc: old_block ? proc { |data| old_block.call(data) } : proc { |data| data },
+            data: 0
+          }
+
+          if amnt == true || amnt.nil?
+            ctx.deferred_options[sw][:data] += 1
+          else
+            ctx.deferred_options[sw][:data] = amnt
+          end
+
+          OptParse2::DONT_ASSIGN
+        end
+
+      in :count!
+        @block = ->(amnt, *a, **k, &b) do
+          ctx = OptParse2::Context.current
+
+          ctx.deferred_options[sw] ||= { data: 0 }
+
+          if amnt == true || amnt.nil?
+            ctx.deferred_options[sw][:data] += 1
+          else
+            ctx.deferred_options[sw][:data] = amnt
+          end
+
+          new_amnt = old_block ? old_block.call(ctx.deferred_options[sw][:data], *a, **k, &b) : ctx.deferred_options[sw][:data]
+          ctx.deferred_options[sw][:data] = new_amnt unless OptParse2::DONT_ASSIGN.equal? new_amnt
+
+          new_amnt
+        end
+
+      in :collect | [:collect, _]
+        transform = Array(multiple)[1]
+        @block = ->(arg, **nil) do
+          ctx = OptParse2::Context.current
+          ctx.deferred_options[sw] ||= {
+            proc: proc { |data| old_block ? old_block.call(data) : data },
+            data: []
+          }
+
+          ctx.deferred_options[sw][:data] << (transform ? transform.(arg) : arg)
+          OptParse2::DONT_ASSIGN
+        end
+
+      else
+        raise ArgumentError, "invalid multiple type: #{multiple}", caller(2)
+      end
+    end
+
+    # Same as `switch_name`, except it also will set the block to just return the original switch
+    # name as a symbol. Useful for group switches which don't actually have blocks:
+    #    op.on '--interactive', key: :mode
+    #    op.on '--force', key: :mode
+    # instead of:
+    #    op.on '--interactive', key: :mode do :interactive end
+    #    op.on '--force', key: :mode do :force end
+    # without this method, passing `--interactive` would just set `:mode` to `true`.
+    #
+    # This only happens if no block exists, and the argument does not take an arg.
+    def set_switch_name_possibly_block_value(val)
+      if @block.nil? && @arg.nil?
+        old_switch_name = switch_name.to_sym
+        @block = proc { old_switch_name }
+      end
+
+      self.switch_name = val
+    end
+
+    # Default values of switches are used when the switch is never passed in.
+    # If the `value` that's provided doesn't respond to `.call`, it's converted to a proc.
+    # If `bypass` is truthy, then the default value is never passed to the block's proc (if any)
+    def set_default(value, description, bypass)
+      if @arg.nil? && value != true && !bypass
+        raise ArgumentError, "Cannot supply a non-true default value to a flag which takes no arguments", caller(4)
+      end
+
+      if defined? value.call
+        @default_proc = value
+      else
+        @default_proc = proc { |_switch_name| value }
+      end
+
+      @default_description = description
+      @default_bypass = bypass
+    end
+
+    # Calls the default proc to figure out what the default value is for this switch
+    def default_bypass? = @default_bypass
+    def default? = defined?(@default_proc)
+    def default = @default_proc&.call(switch_name)
+
+    def default_description = @default_description || default.inspect
+    def desc
+      return super unless defined? @default
+      x = super
+      x << '' if x.empty?
+      x[-1] += " [default: #{default_description}]"
+      x
+    end
+  end
+end

data/lib/optparse2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class OptParse2
-  VERSION = "0.5.3"
+  VERSION = "0.7.0"
 end

data/lib/optparse2.rb

@@ -6,6 +6,8 @@ OptionParser2 = OptParse2 # Alias
 
 require_relative "optparse2/version"
 require_relative "optparse2/fixes"
+require_relative "optparse2/switch-helpers"
+require_relative "optparse2/context"
 
 class OptParse2
   class << self
@@ -18,54 +20,26 @@ class OptParse2
     @positional = []
     @required = Set[]
     @rest = nil
+    @group = nil
     self.pos_set_banner = OptParse2.pos_set_banner
     super
   end
 
-  ## Helpers is a mixin that contains methods to modify how the original `Switch` works
-  module Helpers
-    def set_hidden
-      def self.summarize(*) end
-    end
-
-    attr_writer :switch_name
-    def switch_name; defined?(@switch_name) ? @switch_name : super end
-
-    def set_switch_name_possibly_block_value(val)
-      if @block.nil? && @arg.nil?
-        q = switch_name.to_sym
-        @block = proc { q }
-      end
-
-      self.switch_name = val
-    end
-
-
-    # requires `switch_name`, `desc` to work
-    def set_default(value, description)
-      if defined? value.call
-        @default = value
-      else
-        @default = proc { value }
-      end
-
-      @default_description = description
-    end
-
-    def default = @default.call(switch_name)
-    def default_description = @default_description || default.inspect
-    def desc
-      return super unless defined? @default
-      x = super
-      x << '' if x.empty?
-      x[-1] += " [default: #{default_description}]"
-      x
-    end
-  end
+  # A constant that, when returned, will not actually assign objects inside `into:`s.
+  DONT_ASSIGN = Object.new.freeze
 
   # Update `make_switch` to support OptParse2's keyword arguments
-  def make_switch(opts, block, hidden: false, key: nil, default: nodefault=true, default_description: nil,
-    required: false)
+  def make_switch(
+    opts,
+    block,
+    hidden: false,
+    key: @group,
+    default: nodefault=true,
+    default_bypass: false,
+    default_description: nil,
+    required: false,
+    multiple: nil
+  )
     sw, *rest = super(opts, block)
 
     sw.extend Helpers
@@ -73,6 +47,7 @@ class OptParse2
       sw.set_switch_name_possibly_block_value key
     end
     sw.set_hidden if hidden
+    sw.set_multiple multiple if multiple
 
     if (not_style = rest[2])
       not_style.extend Helpers
@@ -89,8 +64,10 @@ class OptParse2
 
     if nodefault && default_description != nil
       raise ArgumentError, "default: not supplied, but default_description: given"
+    elsif nodefault && default_bypass
+      raise ArgumentError, "default: not supplied, but default_bypass: given"
     elsif not nodefault
-      sw.set_default(default, default_description)
+      sw.set_default(default, default_description, default_bypass)
       @defaults << sw
     end
 
@@ -102,26 +79,31 @@ class OptParse2
     on_tail("\n" + msg)
   end
 
-  def order!(argv = default_argv, into: nil, **keywords, &nonopt)
-    if into.nil? && !@defaults.empty?
-      raise "cannot call `order!` without an `into:` if there are default values"
-    end
-
-    already_done = {}
-    already_done.define_singleton_method(:[]=) do |key, value|
-      super(key, value)
-      into[key] = value
+  def group(name, default: nodefault=true)
+    old_group, @group = @group, name
+    yield
+    if !nodefault && !@defaults.any? { |x| x.switch_name.to_sym == name }
+      (orig_default = default; default = proc { orig_default }) unless default.respond_to?(:call)
+      @defaults << Struct.new(:switch_name, :default_){ def default = default_.() }.new(name, default) # TODO: This should probably be extracted out into a class lol
     end
+  ensure
+    @group = old_group
+  end
 
-    non_options = []
+  alias _super_order! order!
 
-    result = super(argv, into: already_done, **keywords, &non_options.method(:<<))
+  # Parses all positional arguments from `argv` into `into`. Replaces `argv` with non-positional
+  # arguments when it's done.
+  private def parse_positional_arguments!(argv, context, keywords)
+    return if argv.empty? || @positional.empty?
 
-    argv2 = (non_options + result).each_with_index.flat_map { ["--*-positional-#{_2}", _1] }
+    # Prepend argument number to the argument array
+    argv.replace argv.each_with_index.flat_map { |value, idx| ["--*-positional-#{idx}", value] }
 
+    # Fetch all positional arguments using the same option parsing code
     old_raise, self.raise_unknown = self.raise_unknown, false
     begin
-      super(argv2, into: already_done, **keywords)
+      p _super_order!(argv, into: context, **keywords)
     rescue OptParse::InvalidArgument => err
       err.args[0] = @positional[err.args[0][/\d+/].to_i].name
       raise
@@ -129,33 +111,74 @@ class OptParse2
       self.raise_unknown = old_raise
     end
 
-    argv2 = argv2.each_slice(2).map { _2 }
+    # Delete any non-matching arguments. TODO: Can this be the return value of `_super_order!` ?
+    argv.replace argv.each_slice(2).map { |_flag_name, value| value }
+  end
 
+  # If a "rest" parameter was given, populates it. Also raises a ParseError exception for unexepcted
+  # positionals if no `.rest` parameter is present, `self.raise_unknown` is set, and at least one `.pos`
+  # positional argument was supplied
+  private def parse_rest_argument!(argv, context)
     if @rest
-      if argv2.length < @rest.fetch(:required, 0)
-        raise ParseError, "at least #{@rest[:required]} trailing arguments required (only got #{argv2.length})", caller(1)
+      if argv.length < @rest.fetch(:required, 0)
+        raise ParseError, "at least #{@rest[:required]} trailing arguments required (only got #{argv.length})", caller(1)
       end
 
-      argv2 = @rest[:block] ? @rest[:block].call(argv2) : argv2
-      into[@rest[:key]] = argv2.dup if @rest[:key]
-      argv2.clear
-    elsif !argv2.empty? && self.raise_unknown && !@positional.empty?
-      raise ParseError, "got unexpected positional argument: #{argv2.first}", caller(1)
-    else
-      argv2.each(&nonopt)
+      argv = @rest[:block] ? @rest[:block].call(argv) : argv
+      context[@rest[:key]] = argv.dup if @rest[:key]
+      argv.clear
+    elsif !argv.empty? && self.raise_unknown && !@positional.empty?
+      raise ParseError, "got unexpected positional argument: #{argv.first}", caller(1)
     end
+  end
+
+  # Goes thru every default option, and calls
+  private def assign_defaults!(context)
+    visit :each_option do |sw|
+      next if !sw.default? || context.key?(key = sw.switch_name.to_sym)
 
-    @defaults.each do |sw|
-      key = sw.switch_name.to_sym
-      next if already_done.key? key
-      into[key] = sw.default()
+      if sw.default_bypass?
+        context[key] = sw.default
+      else
+        flag = sw.short.first || sw.long.first || raise("<INTERNAL ERROR: CAN THIS EVER HAPPEN?>")
+        _super_order! [flag, sw.default], into: context
+      end
     end
+  end
 
+  private def ensure_all_required_arguments_were_supplied!(context)
     @required.each do |key|
-      raise ParseError, "required option '#{key}' not provided" unless already_done.key? key.to_sym
+      raise ParseError, "required option '#{key}' not provided" unless context.key? key.to_sym
     end
+  end
+
+  def order!(argv = default_argv, into: nil, **keywords, &nonopt)
+    Context.with_context into:, nonopt: do |context|
+
+      # Parse all normal options in the command line
+      non_options = []
+      trailing_options = super(argv, into: context, **keywords, &non_options.method(:<<))
+      not_matched_options = non_options + trailing_options
+
+      # Now parse positional arguments and the "rest" argument
+      parse_positional_arguments!(not_matched_options, context, keywords)
+      parse_rest_argument!(not_matched_options, context)
+
+      context.handle_deferred!
 
-    argv2
+      # Now handle defaults---anything with a default that hasn't been assigned so far is set
+      assign_defaults!(context)
+
+      # Now that all arguments are parsed, and the defaults have been handled, check to make sure
+      # that all required arguments are handled.
+      ensure_all_required_arguments_were_supplied!(context)
+
+      # For each non-option argument, call the `nonopt` block
+      not_matched_options.each(&nonopt)
+
+      # Replace the original argv with the resulting options
+      argv.replace not_matched_options
+    end
   end
 
   module Positional
@@ -236,10 +259,56 @@ class OptParse2
     title += " (#{required} arg minimum)" if required > 0
 
     on sprintf "%s%-*s %s", summary_indent, summary_width, title, description.first
-    description[1..].each do |descr|
+    description[1..]&.each do |descr|
       on sprintf "%s%-*s %s", summary_indent, summary_width, '', descr
     end
 
     @rest = { name:, key:, required: required || 0, block: }
   end
 end
+
+__END__
+OptParse2.new do |op|
+  op.on '--foo=FOO', multiple: :first! do puts "FOO: #{it}"; it end
+  op.on '--bar=BAR'                   do puts "BAR: #{it}"; it end
+
+  op.on '-v', '--verbose[=X]', Integer, multiple: :count
+
+  # op.on '-v', '--verbose[=X]', Integer, multiple: :count! do
+  #   puts "verbose is: #{it}"
+  #   it
+  # end
+
+  op.on '-aF', Integer, multiple: [:collect, :succ.to_proc] do |x|
+    p x
+  end
+
+  op.parse! %w[ -vvv --foo=abc --bar=123 --foo=xyz -a3 -a4 -a5 ], into: opts={}
+  p opts
+end
+
+# OptParse.new do |op|
+#   op.on '--foo=bar', /(.)(.)/ do |x| p x end
+#     op.parse! %w[ --foo=34 ]
+# end
+__END__
+OptionParser2.new do |op|
+  op.on '-e', default: true
+  op.on '--bar1=ALL', default: 'hello', &:upcase
+  op.on '--doit=WHAT', /(.)(.)/, key: :A, default: 'xu' do
+    p [_1, _2, 'both!']
+  end
+
+  op.pos 'foo', required: true do 3 end
+  op.pos 'bar', required: true
+  op.pos 'baz', required: false
+  op.pos 'quux', required: false
+  # op.rest 'files'
+
+
+  rest = op.order!(argv = %w[ --doit 3q a b ] , into: opts={})
+
+  puts "rest=#{rest}"
+  puts "argv=#{argv}"
+  puts "opts=#{opts}"
+end

data/publish

@@ -78,4 +78,7 @@ update_version unless $version.nil?
 ####################################################################################################
 
 system('gem', 'build', exception: true)
-system('gem', 'push', "#$gem-#$version.gem", exception: true) unless $dry
+unless $dry
+  system('gem', 'push', "#$gem-#$version.gem", exception: true)
+  system('gem', 'install', $gem, exception: true)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: optparse2
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.7.0
 platform: ruby
 authors:
 - SamW
@@ -19,8 +19,10 @@ files:
 - README.md
 - Rakefile
 - lib/optparse2.rb
+- lib/optparse2/context.rb
 - lib/optparse2/fixes.rb
 - lib/optparse2/pathname.rb
+- lib/optparse2/switch-helpers.rb
 - lib/optparse2/version.rb
 - publish
 - sig/optparse2.rbs