flex_args 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8116ea5ced17c3ede88f189de179d0c79cad45852e04df7ad315e58a36c9604
-  data.tar.gz: 939170153910604499bed507c48bfe3f6d44c0b7909bf716b79471da6e18eb51
+  metadata.gz: 4e573bedff931ba6d00a805a59c72c1501b454ce2de48efd1787d4e9d3582541
+  data.tar.gz: a33de0609ca8726513b5576f9ce5b9dec7c6ae7a0d9438d3151ce2e03a87c0c3
 SHA512:
-  metadata.gz: be410b8d094de0e4070a7a0fe4b6a49117fb60fb6904f17a488878c0374a4e1556280d5ab1ed3d7c917732e0b85c2d077359a94b6842a29bed5ca49c7a1be3e1
-  data.tar.gz: 93dec0a974b675939584a223eb9e4a551208f942df45bf71bd577f17aa0f6496af27b6a7c381b5cf1cc94958508722cbbddb1570622c9d7fbec6bec1d3842643
+  metadata.gz: e6a44342146b8d223a593a2982f2930bec00db7c93ee8f604ddfa10fd0380562d0ce8577bd636e8fe54082acaf49a39627e4c1dd969898a79c363e911bcf968b
+  data.tar.gz: 45955b80f48f89a16d0b64caf3fbb6a14fbbf0e39fb84e625a7201678bd656d246c73c6d6bb86930e4b8e8a3d5bd9ab5fa927ea4489723674cc69f19448bcca5

data/.rdoc_options

@@ -0,0 +1,27 @@
+---
+encoding: UTF-8
+static_path: []
+rdoc_include: []
+page_dir:
+apply_default_exclude: true
+autolink_excluded_words: []
+charset: UTF-8
+class_module_path_prefix:
+embed_mixins: false
+exclude: [tmp/*,coverage/*]
+file_path_prefix:
+hyperlink_all: false
+line_numbers: false
+locale_dir: locale
+locale_name:
+main_page:
+markup: markdown
+output_decoration: true
+show_hash: false
+skip_tests: true
+tab_width: 8
+template_stylesheets: []
+title:
+visibility: :protected
+warn_missing_rdoc_ref: true
+webcvs:

data/README.md

@@ -1,3 +1,3 @@
 # flex_args
 
-Flexible Argument Parse
+Flexible Argument Parser

data/lib/flex_args/constraint.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+class FlexArgs
+  class Constraint
+
+    attr_reader :name
+
+    ##
+    # ## Creates a new constraint for the value argument named `name`
+    #
+    # Constraints can be many, which is indicated by the first element
+    # in the `constraints` list, or a constraint can be indicated by
+    # a custom made block.
+    #
+    # The available constraints are:
+    #
+    # ### `Regexp` constraint
+    #
+    # These rdoc_specs show the interface that the `FlexArgs::Parser` uses
+    # to validate constraints, the class is therefore part of the public
+    # API and can be used in isolation where it serves.
+    #
+    # ```spec # regexp
+    #     new(:for_some_value, %r{x}).("x") => [:ok, "x"]
+    #     new(:for_some_value, %r{x}).("y") => [:error, "regexp constraint for_some_value: (?-mix:x) violated by value \"y\""]
+    # ```
+    #
+    # ### `Range` constraint
+    #  
+    # ```spec # range
+    #     new(:for_some_int, 1..9).("1") => [:ok, 1]
+    #     new(:for_some_int, 1..9).("0") => [:error, "range constraint for_some_int: 1..9 violated by value \"0\""]
+    #     new(:for_some_int, 1..9).("y") => [:error, "range constraint for_some_int: 1..9 violated by value \"y\""]
+    #
+    #     new(:for_string, "a".."c").("a") => [:ok, "a"]
+    #     new(:for_string, "a".."c").("d") => [:error, 'member constraint for_string: "a".."c" violated by value "d"']
+    #     
+    # ```
+    #
+    # **N.B.** that ranges not of type integer are treated as `Member` contraints below.
+    #
+    # ### `Member` constraint
+    #
+    # While the `Range` constraint above does int type casting if needed, the `Member` constraint cannot do
+    # that, because it cannot access the type of the container against which membership will be tested.
+    #
+    # `Member` constraints can be triggered by providing a `Set`, `Array` or `Hash` second parameter 
+    #
+    # ```spec # Various membership rdoc specs
+    #     vowels = %w[a e i o u y]
+    #     hashy = Hash[vowels.product([true])]
+    #     set = Set.new(vowels)
+    #     in_array = new(:in_array, vowels)
+    #     in_set   = new(:in_set, set)
+    #     in_hash  = new(:in_hash, hashy)
+    #
+    #     expect(in_array.("a")).to eq([:ok, "a"])
+    #     expect(in_array.("y")).to eq([:ok, "y"])
+    #     expect(in_set.("y")).to eq([:ok, "y"])
+    #     expect(in_hash.("o")).to eq([:ok, "o"])
+    #
+    #     expect(in_array.("b"))
+    #       .to eq([:error, "member constraint in_array: #{vowels.inspect} violated by value \"b\""])
+    #
+    #     expect(in_hash.("ec"))
+    #       .to eq([:error, "member constraint in_hash: #{hashy.inspect} violated by value \"ec\""])
+    #
+    #     expect(in_set.("aa"))
+    #       .to eq([:error, "member constraint in_set: #{set.inspect} violated by value \"aa\""])
+    # ```
+    #
+    # ### Custom constraint
+    #
+    # This is easily implemented by passing a block which will return a pair as described above, but also note
+    # two more features of the custom constraint
+    #
+    # - exceptions will be caught and transformed into an error, thusly simplyfing the code block:
+    # - and values can be transformed
+    #
+    # ```spec # custom
+    #    constraint = new :even do
+    #      value = Integer(it)
+    #      value.even? ? [:ok, value / 2] : [:error, "not even"]
+    #    end
+    #
+    #    expect(constraint.("84")).to eq([:ok, 42])
+    #    expect(constraint.("21")).to eq([:error, "custom constraint even: violated by value \"21\" with message: \"not even\""])
+    #   
+    #    exception_message = '"invalid value for Integer(): \\"abc\\" (ArgumentError)"'
+    #    complete_message = "custom constraint even: violated by value \"abc\" with message: #{exception_message}"
+    #    expect(constraint.("abc")).to eq([:error, complete_message])
+    # ```
+    #
+    # Also note that the correct format of the block's return value is important
+    #
+    # ```spec # enforce correct format of custom constraint's block
+    #    constraint = new(:bad) { 42 }
+    #    
+    #    expect { constraint.(nil) }
+    #     .to raise_error(ArgumentError, "badly formatted custom block for custom constraint bad returned 42, needed [:ok|:error, value_or_message]")
+    # ```
+    #
+    def initialize(name, *constraints, &block)
+      @name = name
+      case constraints
+      in [Regexp => constraint]
+        _init_regexp(name, constraint)
+      in [Range => range]
+        _init_range(name, range)
+      in [Array | Hash | Set => container]
+        _init_membership(name, container, false)
+      in [Array | Hash | Set => container, :autocast]
+        _init_membership(name, container, true)
+      in [:member, container]
+        _init_membership(name, container)
+      else
+        raise ArgumentError,
+          "illegal constraint spec #{constraints.inspect} for value #{name}" unless block
+        _init_custom(name, &block)
+      end
+    end
+
+    def call(value)
+      @constrainer.(value)
+    end
+
+    private
+
+    def _init_custom(name, &block)
+      bad_format = false
+      @constrainer = -> value do
+        case block.(value)
+        in [:error, message]
+          _make_error(:custom, name, nil, value, message)
+        in [:ok, _] => result
+          result
+        in result 
+          bad_format = true
+          raise ArgumentError, "badly formatted custom block for custom constraint #{name} returned #{result.inspect}, needed [:ok|:error, value_or_message]"
+        end
+      rescue Exception => e
+        raise if bad_format
+        _make_error(:custom, name, nil, value, "#{e.message} (#{e.class})")
+      end
+    end
+
+    def _init_membership(name, container, autocast)
+      @constrainer = -> value do
+        if container.member?(value) 
+          [:ok, value]
+        elsif autocast
+          case _to_int(value)
+          in [:ok, int_val]
+            if container.member(int_val)
+              [:ok, int_val]
+            else
+              _make_error(:member, name, container.inspect, int_value)
+            end
+          else
+            _make_error(:member, name, container.inspect, value)
+          end
+        else
+          _make_error(:member, name, container.inspect, value)
+        end
+      end
+    end
+
+    def _init_range(name, range)
+      if Integer === range.first
+        _init_int_range(name, range)
+      else
+        _init_membership(name, range, false)
+      end
+    end
+
+    def _init_int_range(name, range)
+      @constrainer = -> value do
+        case _to_int(value)
+        in [:ok, int_val]
+          if range === int_val
+            [:ok, int_val]
+          else
+            _make_error(:range, name, range, value)
+          end
+        else
+          _make_error(:range, name, range, value)
+        end
+      end
+    end
+
+    def _init_regexp(name, constraint)
+      @constrainer = -> value do
+        if constraint.match?(value)
+          [:ok, value]
+        else
+          [:error, "regexp constraint #{name}: #{constraint} violated by value #{value.inspect}"]
+        end
+      end
+    end
+
+    def _make_error(type, name, constraint_desc, value, message = nil)
+      message = [
+        type,
+        "constraint",
+        "#{name}:",
+        constraint_desc,
+        "violated by value",
+        value.inspect,
+        (message ? "with message: #{message.inspect}" : nil)
+      ].compact.join(" ")
+      [:error, message]
+    end
+
+    def _to_int(value)
+      [:ok, Integer(value)]
+    rescue ArgumentError
+      :error
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/flex_args/enumerable.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Enumerable
+  def reduce_while(init, tag=nil, &block)
+    result = 
+      reduce(init) do |i, e|
+        case block.(i, e)
+        in [:halt, value]
+          return value
+        in [:cont, value]
+          value
+        end
+      end
+
+    tag ? [tag, result] : result
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/flex_args/parser.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative 'enumerable'
+
+class FlexArgs
+  class Parser
+    attr_reader :args, :errors, :flags, :flex_args, :positionals, :values_from_args
+
+    ESCAPED_COMMA = "a4ey8NGnXIVhsV"
+    DIGITS = %r{\A [-+]? \d+ \z}x
+    MANY_FLAGS = %r{\A - (.*) \z}x
+    RANGE = %r{\A [-+]? \d+ \.\. [-+]? \d+ \z}x
+    SINGLE_FLAG = %r{\A -- (.*) \z}x
+    VALUE = %r{\A ([[:alpha:]][[:alnum:]_]*) : (.*) \z}x
+
+    def parse(args)
+      init_values
+      args.each { parse_arg it }
+      return [:ok, result] if errors.empty?
+
+      [:error, errors]
+    end
+
+    private
+    def initialize(flex_args)
+      @flex_args = flex_args
+      init_values
+    end
+
+    def add_flags(shorts)
+      shorts.each do
+        flag = flex_args.alias_definitions.fetch(it, it)
+        flags << flag.to_sym
+      end
+    end
+
+    def add_value(matches)
+      matches => [key, value]
+      key = key.to_sym
+      check_allowed!(key)
+      case check_constraints!(key, value)
+      in [:error, message]
+        errors << message
+      in [:ok, value]
+        values_from_args
+          .update(key => cast_all(value)) do |k, o, n|
+            Array(o) << n
+          end
+      end
+    end
+
+    def cast(value)
+      case value
+      when RANGE
+        Range.new(*value.split("..").map(&:to_i))
+      when DIGITS
+        value.to_i
+      else
+        value.gsub(ESCAPED_COMMA, ",")
+      end
+    end
+
+    def cast_all(value)
+      return value unless String === value
+      value = value.gsub(",,", ESCAPED_COMMA)
+      values =
+        value
+        .split(",")
+        .map { cast it }
+      values.one? ? values.first : values
+    end
+
+    def check_allowed!(key)
+      errors << "unallowed value arg #{key}:" unless flex_args.allowed?(key)
+    end
+
+    def check_constraints!(key, value)
+      constraints = flex_args.constraints(key)
+      constraints.reduce_while(value, :ok) do |v, constraint|
+        case constraint.(v)
+        in [:ok, val]
+          [:cont, val]
+        in [:error, message]
+          [:halt, [:error, message]]
+        end
+      end
+    end
+
+    def init_values
+      @errors = []
+      @flags = Set.new
+      @positionals = []
+      @values_from_args = Hash.new
+    end
+
+    def parse_arg(arg)
+      # require "debug"; binding.break
+      case arg
+      when SINGLE_FLAG
+        flags << Regexp.last_match[1].to_sym
+      when MANY_FLAGS
+        add_flags(Regexp.last_match[1].grapheme_clusters)
+      when VALUE
+        add_value(Regexp.last_match)
+      else
+        positionals << arg
+      end
+    end
+
+    def result
+      OpenStruct.new(
+        positionals: positionals,
+        flags: flags,
+        values: values,
+      )
+    end
+
+    def values
+      flex_args
+        .default_values
+        .merge(values_from_args)
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/flex_args/transform.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class FlexArgs
+  class Transform
+
+    def call(value) = [:ok, @transformer.(value)]
+
+    private
+    def initialize(*transformers, &transformer)
+      case transformers
+      in [_]
+        raise ArgumentError, "NOT YET IMPLEMENTED"
+      else
+        _init_transformer(&transformer)
+      end 
+    end
+
+    def _init_transformer(&transformer)
+      @transformer = transformer
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/flex_args/version.rb

@@ -2,7 +2,7 @@
 
 class FlexArgs
   module Version
-    VERSION="0.1.1"
+    VERSION="0.1.3"
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/flex_args.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'ostruct'
+require_relative 'flex_args/constraint'
+require_relative 'flex_args/parser'
+require_relative 'flex_args/transform'
 
 ##
 # ## Abstract
@@ -14,11 +17,11 @@ require 'ostruct'
 # ### Positional arguments
 #
 # Are all arguments that do not:
-#   
+#
 #   - start with a `-`
 #   - contain any of the following characters: `:,`
 #   - contain the string `".."`
-# 
+#
 # Therefore the following arguments will be parsed as
 #
 # ```spec # Only default positional arguments
@@ -89,28 +92,26 @@ require 'ostruct'
 #      - required
 #      - domain checks
 #      - format checks
-#   - Custom Transformations
-#   - Semantic Checks (v0.2)
+#   - Transformations
+#   - Semantic Checks - between multiple values (v0.2)
 #
 # and they are documented in the rdocs of the corresponding methods
 #
 class FlexArgs
 
-  ESCAPED_COMMA = "a4ey8NGnXIVhsV" 
-  DIGITS = %r{\A [-+]? \d+ \z}x
-  MANY_FLAGS = %r{\A - (.*) \z}x
-  RANGE = %r{\A [-+]? \d+ \.\. [-+]? \d+ \z}x
-  SINGLE_FLAG = %r{\A -- (.*) \z}x
-  VALUE = %r{\A ([[:alpha:]][[:alnum:]_]+) : (.*) \z}x
-
-  attr_reader :alias_definitions, :flags, :positionals, :result, :values
+  attr_reader :alias_definitions, :default_values, :result
 
   def parse(args)
-    init_values
-    args.each { parse_arg it }
-    result
+    result = Parser.new(self).parse(args)
+    case result
+    in [:ok, result1]
+      result1
+    in [:error, errors]
+      raise ArgumentError, errors.join("\n")
+    end
   end
 
+
   ##
   #
   # ## Aliases are defined by passing a hash
@@ -136,78 +137,205 @@ class FlexArgs
     self
   end
 
-  private
-  def initialize
-    @alias_definitions = Hash.new
-    init_values
+  ##
+  # ## Allowed values and flags
+  #
+  # As soon as this method is called the parser will
+  # check that **all** values in args are allowed
+  #
+  # Values are either identified by their name (a `Symbol`)
+  # or by their name and default value (a pair of `Symbol` and
+  # any value
+  #
+  # ```spec
+  #   parser = FlexArgs
+  #     .new
+  #     .allow(:min, [:max, 3])
+  #
+  #   expect(parser.parse(%w[min:1]).values)
+  #     .to eq(min: 1, max: 3)
+  # ```
+  # 
+  # Therefore the following args are illegal and an `ArgumentError`
+  # is raised
+  #
+  # ```spec # Argument Error for unallowed value
+  #   expect do
+  #     FlexArgs
+  #       .new
+  #       .allow(:n)
+  #       .parse(%w[a:2])
+  #   end
+  #     .to raise_error(
+  #       ArgumentError,
+  #       "unallowed value arg a:"
+  #     )
+  #   
+  # ```
+  # 
+  def allow(*values)
+    values.each { allow_value it }
+    self
   end
 
-  def add_flags(shorts)
-    shorts.each do
-      flag = alias_definitions.fetch(it, it)
-      flags << flag.to_sym
-    end
+  def allowed?(value)
+    return true unless @allowed_values
+    @allowed_values.member?(value)
   end
 
-  def add_value(matches)
-    matches => [key, value]
-    values
-      .update(key.to_sym => cast_all(value)) do |k, o, n|
-        Array(o) << n
-      end
-  end
+  def constraints(key) = @constraints[key]
 
-  def cast(value)
-    case value
-    when RANGE
-      Range.new(*value.split("..").map(&:to_i))
-    when DIGITS
-      value.to_i
-    else
-      value.gsub(ESCAPED_COMMA, ",")
-    end
+  ##
+  # ## Constraints
+  #
+  #  Constraints are defined with the `constraint` method.
+  #  
+  #  **N.B.** defined Constraints **after** allow unless you
+  #  want to explicitly add the value arg with `allow`
+  #  
+  # ### Simple forms
+  #
+  # #### Regexp constraint
+  #
+  # ```spec # regexp constraints
+  #    parser = FlexArgs
+  #               .new
+  #               .constrain(:n, %r{\A \d+ \z}x)
+  #
+  #   expect(parser.parse(%w[n:42]).values).to eq(n: 42)
+  #
+  #   expect { parser.parse(%w[n:42a]) }
+  #     .to raise_error(ArgumentError, 'regexp constraint n: (?x-mi:\A \d+ \z) violated by value "42a"')
+  #
+  # ```
+  #
+  # #### Range constraints
+  #
+  # ```spec # range constraints
+  #     parser = FlexArgs
+  #                .new
+  #                .constrain(:n, 2..3)
+  #
+  #   expect(parser.parse(%w[n:2]).values).to eq(n: 2)
+  #
+  #   expect { parser.parse(%w[n:42a]) }
+  #     .to raise_error(ArgumentError, 'range constraint n: 2..3 violated by value "42a"')
+  #
+  #   expect { parser.parse(%w[n:42]) }
+  #     .to raise_error(ArgumentError, 'range constraint n: 2..3 violated by value "42"')
+  #
+  # ```
+  #
+  # #### Combining Constraints
+  #
+  # More than one constraint can be imposed on a value
+  # 
+  # Firstly one can combine any constraint with a custom constraint.
+  #
+  # **N.B.** That in this case the custom constraint is executed last, therefore
+  #
+  # ```spec # Order of constraints
+  #    parser = FlexArgs.new
+  #      .constrain(:n, 1..10) { it == 5 ? [:ok, 100] : [:ok, 2*it] }
+  #
+  #    expect(parser.parse(%w[n:5]).values).to eq(n: 100)
+  #
+  # ```
+  #
+  # However if we had defined the custom constraint (which actually is a transformer
+  # as it _always_ returns an `:ok` value, the range constraint would fail
+  #
+  # ```spec # Bad order
+  #    parser = FlexArgs.new
+  #      .constrain(:n) { it == 5 ? [:ok, 100] : [:ok, 2*it] }
+  #      .constrain(:n, 1..10)
+  #
+  #    expect { parser.parse(%w[n:5]) }
+  #    .to raise_error(ArgumentError)
+  #   
+  # ```
+  # 
+  # As mentioned before, custom constraints that always return `:ok` values are indeed
+  # _transformers_ and can be written more with the `transform` [method below](/FlexArgs.html#method-i-transform-label-Transformers)
+  #
+  #
+  # Please find the documentation about more constraints [here](/FlexArgs/Constraint.html)
+  #
+  def constrain(value, *constraints, &block)
+    @allowed_values << value.to_sym if @allowed_values
+    @constraints[value.to_sym] << Constraint.new(value, *constraints) unless constraints.empty?
+    @constraints[value.to_sym] << Constraint.new(value, &block) if block
+    self
   end
 
-  def cast_all(value)
-    value = value.gsub(",,", ESCAPED_COMMA)
-    values = 
-      value
-      .split(",")
-      .map { cast it }
-    values.one? ? values.first : values
+  ##
+  # ## Transformers
+  #
+  # Transformers and Constraints are executed in the order they are defined
+  #
+  # ```spec # Transformer assures constraint passes
+  #
+  #     parser = FlexArgs.new
+  #                .transform(:word) { it.downcase }
+  #                .constrain(:word, "a".."z")
+  #   
+  #     expect(parser.parse(%w[word:A]).values).to eq(word: "a")
+  # ```
+  # 
+  # And therefore
+  #
+  # ```spec # Transformer called too late to assure constraint passes
+  #
+  #     parser = FlexArgs.new
+  #                .constrain(:word, "a".."z")
+  #                .transform(:word) { it.downcase }
+  #   
+  #     expect { parser.parse(%w[word:A]) }.to raise_error(ArgumentError)
+  # ```
+  def transform(value, *transforms, &transformer)
+    @allowed_values << value.to_sym if @allowed_values
+    @constraints[value.to_sym] << Transform.new(*transforms) unless transforms.empty?
+    @constraints[value.to_sym] << Transform.new(&transformer) if transformer
+    self
   end
 
-  def define_alias(short, long)
-    alias_definitions.update(short => long)
+  ##
+  #
+  # Just returns the parsed values, or their default values if
+  # a default was provided and the value was not present in
+  # the provided arguments.
+  def values
+    default_values.merge(values_from_args)
   end
-
-  def init_values
-    @positionals = []
-    @flags = Set.new
-    @values = Hash.new
+ 
+  private
+  def initialize
+    @alias_definitions = Hash.new
+    @allowed_values = nil
+    @constraints = Hash.new { |h, k| h[k] = [] }  
+    @default_values = Hash.new
   end
 
+  def add_default_value(name, value)
+    default_values.update(name => value)
+  end
 
-  def parse_arg(arg)
-    # require "debug"; binding.break
-    case arg
-    when SINGLE_FLAG
-      flags << Regexp.last_match[1].to_sym
-    when MANY_FLAGS
-      add_flags(Regexp.last_match[1].grapheme_clusters)
-    when VALUE
-      add_value(Regexp.last_match)
-    else
-      positionals << arg
+  def allow_value(value_def)
+    @allowed_values ||= Set.new
+    case value_def
+    in Symbol
+      @allowed_values << value_def
+    in [Symbol => value_name, default_value]
+      @allowed_values << value_name
+      add_default_value(value_name, default_value)
+    in _
+      raise ArgumentError, "arg must be of format Symbol or [Symbol, value], but was #{value_def}"
     end
   end
 
-  def result
-    OpenStruct.new(
-      positionals: positionals,
-      flags: flags,
-      values: values,
-    )
+  def define_alias(short, long)
+    alias_definitions.update(short => long)
   end
+
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flex_args
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Robert Dober
@@ -31,9 +31,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rdoc_options"
 - LICENSE
 - README.md
 - lib/flex_args.rb
+- lib/flex_args/constraint.rb
+- lib/flex_args/enumerable.rb
+- lib/flex_args/parser.rb
+- lib/flex_args/transform.rb
 - lib/flex_args/version.rb
 homepage: https://codeberg.org/lab419/flex_args
 licenses: