l43_xargs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6cdd350e54ca66983f13d1e33b3e3e18894f353e4c3fe03a219d30ce1fd6a2d0
+  data.tar.gz: 49af947748b25d788161948d18d37025a27b638ff93c27c3d54dbb2e12ae5df3
+SHA512:
+  metadata.gz: daba987a66ff981117e87d6f1d729e8d347e888b0d9bddeb4396a3c650da1fecbe7e78ce2feec6ca176852e099be512ddfd9448c2ef2647772c510ef854ecad6
+  data.tar.gz: 965d995dc98c035320aeb3cd4c91cd5bd4c71dff26ef081a44f9dc8b3ebb830dc38b8acb0cf27f9f4546a63f6839fba2f70dcc6d4220cb30ce3fe139a7434964

data/lib/l43/xargs/anon_flag.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    class AnonFlag
+      attr_reader \
+        :desc,
+        :name,
+        :value
+ 
+      def defaulted = !value
+
+      private
+      def initialize(name)
+        @desc = [:yellow, "anonymous flag ", :bold, name.inspect]
+        @name = name
+        @value = true
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/anon_keyword.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    class AnonKeyword
+
+      attr_reader \
+        :defaulted, :desc,
+        :name,
+        :value
+
+      private
+      def initialize(name, value)
+        @defaulted = false
+        @desc = [:yellow, "anonymous keyword ", :bold, name.inspect] 
+        @name = name
+        @value = value
+      end
+        
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/check.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    class Check
+
+      attr_reader :check, :desc, :name
+
+      def call(kwds)
+        return if check.(kwds)
+        errors << [:red, :bold, "ERROR: ", :reset, :yellow, "failed check: ", :cyan, _make_description, :reset]
+        errors.freeze
+      end
+
+      def errors =  @__errors__ ||= []
+
+      private
+      def initialize(name:, desc:, &blk)
+        @name = name.freeze
+        @desc = desc.freeze
+        @check = blk
+      end
+
+      def _make_description
+        return desc unless name
+        "#{name} (#{desc})"
+      end
+
+        
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/deconstruct.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    module Deconstruct
+      def deconstruct(*)
+        [ok?, args, errors, kwds]
+      end
+
+      def deconstruct_keys(*)
+        {ok: ok?, args:, errors:, kwds:}
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/defined_args.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'output'
+require_relative 'flag'
+require_relative 'keyword'
+require_relative 'descriptions'
+
+module L43
+  class Xargs
+    class DefinedArgs
+      include Descriptions
+      BadDefinition = Class.new(RuntimeError)
+      DuplicateDefinition = Class.new(BadDefinition)
+
+      def add_desc(desc, element, indent:)
+        element.add_desc([indent || 4, *desc, :reset])
+      end
+
+      def def_flag(long, short=nil, desc:)
+        flag = Flag.new(long, short, desc:)
+        _def_short_flag(short, flag) if short
+        _def_flag(long, flag)
+        # p(defined_kwds: _defined_kwds)
+      end
+
+      def def_kwd(name, short=nil, desc:, default: None, &blk)
+        kwd = Keyword.new(name, short, desc:, default:, &blk)
+        _def_short_kwd(short, kwd) if short
+        _def_kwd(name, kwd)
+        # p(defined_kwds: _defined_kwds, defined_flags: _defined_flags)
+      end
+
+      def get_element(name, &blk)
+        _defined_flags[name] ||
+          _defined_kwds.fetch(name, &blk)
+      end
+
+      def get_flag(long)
+        _defined_flags[long]
+      end
+
+      def get_flags(&blk)
+        _defined_flags.each(&blk)
+      end
+
+      def get_kwd(long)
+        _defined_kwds[long]
+      end
+
+      def get_kwds(&blk)
+        _defined_kwds.each(&blk)
+      end
+
+      def get_missing_kwds(&blk)
+        missing = _defined_kwds.filter { |_, kwd| kwd.required? && kwd.defaulted }
+        missing.each { |_, kwd| blk.(kwd) }
+      end
+
+      def get_short_flag(short)
+        _defined_short_flags[short]
+      end
+      def get_short_kwd(short)
+        _defined_short_kwds[short]
+      end
+
+      def print_help(indent: 1, newline: true, program_name: nil, sections: true, section_colors: [:bold, :green], usage: false, device: $stderr)
+        lines = help_description(indent:, newline:, program_name:, usage:, sections:, section_colors:)
+        lines.each do |line|
+          Output.putc(line, device:, indent:, colorize: @_colorize)
+        end
+      end
+
+      def args = @__args__ ||= []
+
+      def kwds =  @__kwds__ ||= OpenStruct.new 
+
+      private
+      def initialize(colorize:)
+        @_colorize = colorize
+      end
+
+      def _colorize? = @_colorize
+
+      def _def_flag(name, flag)
+        raise DuplicateDefinition, "flag #{name.inspect} already defined" if get_flag(name)
+        _defined_flags[name] = flag
+      end
+
+      def _def_kwd(name, kwd)
+        raise DuplicateDefinition, "keyword #{name.inspect} already defined" if get_kwd(name)
+        _defined_kwds.set!(name, kwd)
+      end
+
+      def _def_short_flag(short, flag)
+        raise DuplicateDefinition, "short flag #{short.inspect} already defined" if get_short_flag(short)
+        _defined_short_flags.set!(short, flag)
+      end
+
+      def _def_short_kwd(short, kwd)
+        raise DuplicateDefinition, "short keyword #{short.inspect} already defined" if get_short_kwd(short)
+        _defined_short_kwds[short] = kwd
+      end
+
+      def _defined_flags =  @__defined_flags__ ||= OpenStruct.new
+
+      def _defined_kwds =  @__defined_kwds__ ||= OpenStruct.new
+
+      def _defined_short_flags =  @__defined_short_flags__ ||= OpenStruct.new
+
+      def _defined_short_kwds =  @__defined_short_kwds__ ||= OpenStruct.new
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/descriptions.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    module Descriptions
+      def help_description(indent: 1, newline: true, program_name: nil, sections: true, section_colors: [:bold, :green], usage: false)
+        flag_section =_section("Flags", indent:, newline:, sections:, section_colors:) unless _defined_flags.empty?
+        kwd_section = _section("Keywords", indent:, newline:, sections:, section_colors:) unless _defined_kwds.empty?
+        usage_section = [:bold, "usage: ", *_maybe_program_name(program_name), *_options(usage)] if usage
+
+        [
+          usage_section,
+          flag_section, 
+          *_flag_descriptions,
+          kwd_section,
+          *_kwd_descriptions,
+        ].compact
+      end
+
+      private
+      def _flag_descriptions
+        _defined_flags.inject([]) do |result, (_, flag)|
+          [*result, *flag.full_description]
+        end
+      end
+
+      def _kwd_descriptions
+        _defined_kwds.inject([]) do |result, (_, flag)|
+          [*result, *flag.full_description]
+        end
+      end
+
+      def _maybe_program_name(program_name)
+        return [] unless program_name
+        [:green, program_name + " "]
+      end
+
+      def _options(*usage)
+        case usage.flatten
+        in options, args
+          [:cyan, "[#{options}] ", :blue, "#{args}..."]
+        in [options]
+          [:cyan, "[#{options}]"]
+        else
+          []
+        end
+      end
+
+      def _section(title, indent:, newline:, sections:, section_colors:)
+        return unless sections
+        newline = newline ? [nil] : []
+        [*newline, indent, *Array(section_colors), title]
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/flag.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    class Flag
+      attr_reader \
+        :additional_desc,
+        :desc,
+        :error,
+        :name,
+        :short,
+        :value
+
+      def add_desc(desc)
+        @additional_desc << desc
+      end
+
+      def defaulted = !value
+
+      def error? = !!@error
+
+      def full_description(indent: 3, colors: :cyan)
+        [
+          [
+            indent, *name_description(colors:), *desc, :reset
+          ],
+          *additional_desc
+        ]
+      end
+
+      def name_description(colors: :cyan)
+        formatted_name = ":#{name} "
+        formatted_name = ":#{short}|#{formatted_name}" if short
+        [*Array(colors), formatted_name, :reset] 
+      end
+
+      def set_error!(error) = @error = error
+
+      def set_true!
+        @value = true
+      end
+
+      private
+      def initialize(name, short=nil, desc:)
+        @additional_desc = []
+        @desc = Array(desc)
+        @error = nil
+        @name = name
+        @short = short
+        @value = false
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/keyword.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    class Keyword
+      CallbackError = Class.new(RuntimeError)
+
+      attr_reader \
+        :additional_desc,
+        :callback,
+        :default, :defaulted, :desc,
+        :name,
+        :short,
+        :value
+
+      def add_desc(desc)
+        @additional_desc << desc
+      end
+
+      def description_name
+        prefix = short ? "#{short}:|" : ""
+        "#{prefix}#{name}:"
+      end
+
+      def default? =  @__default_p__ ||= default != None
+
+      def full_description(indent: 3, colors: :cyan, important: :bold, default_colors: :dim)
+        [
+          [
+            indent, *name_description(colors:), *desc, *_default_description(important:, default_colors:)
+          ],
+          *additional_desc
+        ]#.tap { p it }
+      end
+
+      def name_description(colors: :cyan)
+        formatted_name = "#{name}: "
+        formatted_name = "#{short}:|#{formatted_name}" if short
+        [*Array(colors), formatted_name, :bold, :blue, "<value> ", :reset] 
+      end
+
+      def required? = default == None
+
+      def set_value!(value)
+        @defaulted = false
+        value = callback.(value) if callback
+        @value = value
+        :ok
+      rescue RuntimeError => re
+        [:error, re.class, re.message]
+      rescue ArgumentError => ae
+        [:error, ArgumentError, ae.message]
+      end
+
+      private
+      def initialize(name, short=nil, desc:, default: None, &blk)
+        @callback = blk
+        @default = default
+        @defaulted = true
+        @desc = Array(desc)
+        @name = name
+        @short = short
+        @value = default
+
+        @additional_desc = []
+      end
+
+
+      def _default_description(important:, default_colors:)
+        if default?
+          [:reset, *Array(default_colors), " (defaults to: ", :reset, default.inspect, :dim, ")", :reset]
+        else
+          [:reset, *Array(important), " REQUIRED", :reset] 
+        end
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/open_struct.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'l43/core/forwarder'
+class OpenStruct
+  extend L43::Core::Forwarder
+  forward_all :deconstruc_keys,
+    :each, :empty?,
+    :fetch, :filter,
+    :inject,
+    :map, to: :to_h
+
+  # def deconstruct_keys(*)
+  #   to_h
+  # end
+
+  # def each(&blk) = to_h.each(&blk)
+  # def empty? = to_h.empty?
+  # def filter(&blk) = to_h.filter(&blk)
+  # def map(&blk) = to_h.map(&blk)
+
+  def merge(**values)
+    self.class.new(to_h.merge(**values))
+  end
+
+  def set!(key, value) = self[key.to_sym] = value
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/output.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'l43/color/output'
+
+module L43
+  class Xargs
+    module Output extend self
+      include Color::Output
+
+      def putc(*chunks, indent: 1, device: $stderr, colorize: true)
+        expanded = _expand_chunks(chunks, indent:, colorize:)
+        putcol(expanded, to: device)
+      end
+
+      private
+
+      def _expand_chunks(*chunks, indent:, colorize:)
+        chunks
+          .flatten
+          .inject([]) { |result, chunk| _expand_description(result, chunk, indent:, colorize:) }
+      end
+
+      def _expand_description(result, element, indent:, colorize:)
+        case element
+        when nil
+          [*result, "\n"]
+        when Integer
+          [*result, " " * element * indent]
+        when Symbol
+          if colorize
+            [*result, element]
+          else
+            result
+          end
+        else
+          [*result, element]
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/parse.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    module Parse
+      def _add_defaults
+        # require "debug"; binding.break
+        defined_args.get_flags do |_, flag|
+          _kwds.set!(flag.name, flag)
+          # p(name: flag.name, kwds: _kwds)
+        end
+        defined_args.get_kwds do |_, kwd|
+          if kwd.default != None
+            _kwds.set!(kwd.name, kwd)
+            # p(name: kwd.name, kwds: _kwds)
+          end
+        end
+      end
+
+      def _add_flag(flag)
+        flag_def = defined_args.get_flag(flag)
+        _errors << _colorize("undefined flag: ", :yellow, :bold, ":#{flag}", :reset) unless flag_def 
+        if flag_def
+          _check_multiple_occurence(flag_def, name: flag_def.name)
+          flag_def.set_true!
+          _kwds.set!(flag, flag_def)
+        else
+          _kwds.set!(flag, AnonFlag.new(flag))
+        end
+        argv.shift
+      end
+
+      def _add_kwd(name)
+        argv.shift
+
+        kwd_def = defined_args.get_kwd(name)
+        _errors << _colorize("undefined keyword: ", :yellow, :bold, name.inspect, :reset) unless kwd_def
+
+        if argv.empty?
+          _errors << _colorize(:yellow, :bold, "missing value ", :reset, "for keyword ", name.inspect)
+          raise StopIteration
+        end
+
+        if argv.first == "::"
+          _errors << _colorize(:yellow, :bold, "missing value ", :reset, "for keyword ", name.inspect, " (caused by a following :: which forces the end of argument parsing)")
+          return
+        end
+
+        value = argv.shift
+
+        if kwd_def
+          set_kwd(kwd_def, value)
+        else
+          _kwds.set!(name, AnonKeyword.new(name, value))
+        end
+      end
+
+      def set_kwd(kwd_def, value)
+        case kwd_def.set_value!(value)
+        in :ok
+          _kwds.set!(kwd_def.name, kwd_def)
+        in :error, klass, msg
+          _errors << _colorize(
+            "callback for keyword ", :bold, :cyan, kwd_def.name.to_s + ":", 
+            :reset, :yellow, " raised error ", :bold, klass.to_s,
+            :reset, " with message: ", :bold, msg
+          )
+        end
+      end
+
+      def _add_short_flag(flag, shift: true)
+        flag_def = defined_args.get_short_flag(flag)
+        _errors << _colorize("undefined short flag: ", :yellow, :bold, ":#{flag}", :reset) unless flag_def 
+
+        if flag_def
+          _check_multiple_occurence(flag_def, name: flag_def.short, short: true)
+          flag_def.set_true!
+          _kwds.set!(flag_def.name, flag_def) 
+        else
+          _kwds.set!(flag, AnonFlag.new(flag))
+        end
+        argv.shift if shift
+      end
+
+      def _add_short_kwd(short)
+        argv.shift
+
+        kwd_def = defined_args.get_short_kwd(short)
+        _errors << _colorize("undefined short keyword: ", :yellow, :bold, short.inspect, :reset) unless kwd_def
+
+        if argv.empty?
+          _errors << _colorize(:yellow, :bold, "missing value ", :reset, "for short keyword ", short.inspect)
+          raise StopIteration
+        end
+
+        value = argv.shift
+
+        if kwd_def
+          kwd_def.set_value!(value)
+          _kwds.set!(kwd_def.name, kwd_def)
+        else
+          _kwds.set!(short, AnonKeyword.new(short, value))
+        end
+      end
+
+      def _check_multiple_occurence(flag_def, name:, short: false)
+        # p(name:, value: flag_def.value, error: flag_def.error?)
+        return if !flag_def.value || flag_def.error?
+        error_msg = [:yellow, :bold, "multiple occurences of #{short ? "short " : ""}flag: ", :cyan, name.inspect]
+        _errors << _colorize(*error_msg)
+        flag_def.set_error!(error_msg)
+      end
+
+      def _checks!
+        checks.each do |check|
+          check.(_kwds)
+          check.errors.each do |error|
+            _errors << error
+          end
+        end
+      end
+
+      def _parse
+        _add_defaults
+        loop do
+          _parse_argv
+        end
+        _check_for_missing!
+        _checks!
+        OpenStruct.new(args: _args, errors: _errors, kwds: _kwds)
+      end
+
+      def _parse_argv
+        raise StopIteration if argv.empty?
+        case argv.first
+        when LongFlagRgx
+          _add_flag($1.to_sym)
+        when LongKwdRgx
+          _add_kwd($1.to_sym)
+        when PosixShortFlagsRgx
+          $1.grapheme_clusters.each do
+            _add_short_flag(it.to_sym, shift: false)
+          end
+          argv.shift
+        when StopParsing
+          _args.concat(argv.drop(1))
+          raise StopIteration 
+        when ShortFlagRgx
+          _add_short_flag($1.to_sym)
+        when ShortKwdRgx
+          _add_short_kwd($1.to_sym)
+        else
+          _args << argv.first
+          argv.shift
+        end
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module L43
+  class Xargs
+    VERSION = "0.1.0"
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/xargs.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+# require 'l43/core/forwarder'
+module L43
+  class Xargs
+    None = Object.new.freeze
+  end
+end
+
+require_relative 'xargs/open_struct'
+require_relative 'xargs/check'
+require_relative 'xargs/deconstruct'
+require_relative 'xargs/defined_args'
+require_relative 'xargs/anon_flag'
+require_relative 'xargs/anon_keyword'
+require_relative 'xargs/parse'
+
+module L43
+  class Xargs
+    include Deconstruct
+    include Parse
+
+    IllegalMonitorState = Class.new(RuntimeError)
+    ColorizeValues = %i[always auto never]
+
+    LongFlagRgx = %r{\A:(..+)}
+    LongKwdRgx = %r{\A(..+):\z}
+    PosixShortFlagsRgx = %r{\A-(.+)\z}
+    ShortFlagRgx = %r{\A:(.)\z}
+    ShortKwdRgx = %r{\A(.):\z}
+    StopParsing = "::"
+
+    attr_reader :argv, :autohelp, :defined_args, :last_added, :program_name, :usage
+
+    def add_desc(*desc, indent: nil, name: nil)
+      if name
+        element = defined_args.get_element(name) do
+          raise IllegalMonitorState, "cannot add description for undefined flag or keyword #{name.inspect}"
+        end
+        defined_args.add_desc(desc.flatten, element, indent:)
+      else
+        raise IllegalMonitorState, "cannot add description for last added flag or keyword before adding one" unless last_added
+        defined_args.add_desc(desc.flatten, last_added, indent:)
+      end
+
+      self
+    end
+
+    def args = result.args
+
+    def autohelp!
+      def_flag(:help, :h, desc: "Shows this help and exits") unless autohelp
+      @autohelp = true
+      self
+    end
+
+    def def_check(name=nil, desc:, &blk)
+      checks << Check.new(name:, desc:, &blk)
+      self
+    end
+
+    def def_flag(name, short=nil, desc:)
+      @last_added = defined_args.def_flag(name, short, desc:)
+      self
+    end
+
+    def def_kwd(name, short=nil, desc:, default: None, &blk)
+      @last_added = defined_args.def_kwd(name, short, desc:, default:, &blk)
+      self
+    end
+
+    def errors = result.errors
+
+    def help_description(indent: 1, newline: true, sections: true, section_colors: [:bold, :green])
+      defined_args.help_description(indent:, newline:, program_name:, sections:, section_colors:, usage:)
+    end
+
+    def full_result
+      raise IllegalMonitorState, "must not call full_result before calling parse" unless @__full_result__
+      @__full_result__
+    end
+
+    def kwds = result.kwds
+
+    def ok? = errors.empty?
+
+    def parse(argv)
+      raise IllegalMonitorState, "must not call parse twice on the same instance" if @__full_result__
+      @argv = argv
+      @__full_result__ = _parse
+      self
+    end
+
+    def print_errors
+      _errors.each do |error|
+        Output.putc(error, device: $stderr, indent: 0)
+      end
+    end
+
+    def print_help(indent: 1, newline: true, program_name: nil, sections: true, section_colors: [:bold, :green], usage: false, device: $stderr)
+     defined_args.print_help(indent:, newline:, program_name:, sections:, section_colors:, usage:, device:)
+    end
+
+    def result 
+      raise IllegalMonitorState, "must not call result before calling parse" unless @__full_result__
+      @__result__ ||= _result 
+    end
+
+    def set_program_name!(program_name)
+      @program_name = program_name
+      self
+    end
+
+    def set_usage!(*values)
+      @usage = values.flatten 
+      self
+    end
+
+    private
+    def initialize(autohelp: false, colorize: :auto, program_name: nil, usage: false, &blk)
+      raise ArgumentError, "keyword argument colorize is #{colorize.inspect}, not in required set: #{ColorizeValues.inspect}" unless ColorizeValues.member? colorize
+      raise ArgumentError, "keyword argument autohelp is #{autohelp.inspect}, but a boolean is required" unless [false, true].member? autohelp
+      raise ArgumentError, "blocks are ignored and therefore not supported" if blk
+      @colorize = colorize
+      @usage = usage
+
+      @program_name = program_name
+      @defined_args = DefinedArgs.new(colorize: _colorize?)
+      def_flag(:help, :h, desc: "Shows this help and exits") if autohelp
+    end
+
+    def _args =  @__args__ ||= []
+
+    def _colorize(*chunks)
+      chunks.map do |chunk|
+        _use_chunk(chunk)
+      end.compact
+    end
+
+    def _check_for_missing!
+      defined_args.get_missing_kwds do |kwd|
+        _errors << _colorize(:red, :bold, "ERROR: ", :yellow, "the required keyword ", :cyan, kwd.description_name, :yellow, " is missing")
+      end
+    end
+
+    def checks =  @__checks__ ||= []
+    
+    def _colorize? =  @___colorize_p__ ||= @colorize == :always || @colorize == :auto && ENV['NO_COLOR'].nil?
+
+    def _errors =  @__errors__ ||= []
+
+    def _kwds =  @__kwds__ ||= OpenStruct.new 
+
+    def _result
+      kwds = full_result.kwds.map { |k, v| [k, v.value]}.to_h
+      full_result.merge(kwds:)
+    end
+
+    def _use_chunk(chunk)
+      if _colorize?
+        chunk
+      elsif String===chunk
+        chunk
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: l43_xargs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Dober
+bindir: bin
+cert_chain: []
+date: 2026-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: l43_color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: l43_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+description: |
+  A Modular Tailor Made Command Line Parser
+  Yet another ClParser emerging from my needs for my Ruby Tools.
+  General but with a opinionated Featute Set.
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/l43/xargs.rb
+- lib/l43/xargs/anon_flag.rb
+- lib/l43/xargs/anon_keyword.rb
+- lib/l43/xargs/check.rb
+- lib/l43/xargs/deconstruct.rb
+- lib/l43/xargs/defined_args.rb
+- lib/l43/xargs/descriptions.rb
+- lib/l43/xargs/flag.rb
+- lib/l43/xargs/keyword.rb
+- lib/l43/xargs/open_struct.rb
+- lib/l43/xargs/output.rb
+- lib/l43/xargs/parse.rb
+- lib/l43/xargs/version.rb
+homepage: https://codeberg.org/lab419/l43_opt_parser
+licenses:
+- AGPL-3.0-or-later
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Modular Tailor Made Command Line Parser
+test_files: []