l43_opt_parser 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63be9d1fa069240f7ef6fdd36805bb3af88c50519543465170bfb15dcd1af069
-  data.tar.gz: f54d8f9209b79139f896e8453e78010de27dd3bdd00c0aa6aa6db3f0713c8e4a
+  metadata.gz: 960127bd5fe3d57920703c562c1eb31335d8e1c3abef182ff4e673ee1479e70d
+  data.tar.gz: ba5380ffe585fd5dd198cc11eddedfad056c2d17667e8f446fdaccd34a0fea4d
 SHA512:
-  metadata.gz: fb4bf372fe886ef383b136b964499dbfc861fc6c67b7b58343eb63651b0ecf1b4235e66aacf865d0465f807386c4d330b844463af9c414351f598bf839a4072c
-  data.tar.gz: c332e0cb1dda8032e5636d9c96b5fc99d43f9c588140e3561ac48f0e7ebe7d6d7128bea88b67b968f90dc1a585c48574ad0dc77a1eedf4388adaec5833cce99e
+  metadata.gz: 4da0f00b58bb29dbb69f511e8404a5cb03664ba38ef03933ce7e4ff3e4e4963178d0b9716e0efc79e22534fc081c00ca6d5fe7de127356c2c35f7d7cdd2ce28d
+  data.tar.gz: 20062237a066a5d7eb15da190a36aa5dd74e1a415dab6ffc96dd8a9287374afc11ab125727030f7628b74acd98ec53df6fac6dbbb6c35401b9ba4c565b5f20f0

data/lib/l43/opt_parser/description.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'l43/core/none'
+module L43
+  class OptParser
+    class Description
+
+      def add_desc(*chunks, indent: 5)
+        self << [indent, *chunks]
+      end
+
+      def add_flag(flag, indent: 3, color: :cyan)
+        return unless flag.desc
+        short = flag.short ? ":#{flag.short}|" : ""
+          self <<  [indent, color, short, ":", flag.name.to_s, :reset, 1, flag.desc ] 
+      end
+
+      def add_kwd(kwd, indent: 3, color: :cyan, vcolor: [:bold,:blue])
+        return unless kwd.desc
+        short = kwd.short ? "#{kwd.short}:|" : ""
+        default = kwd.default == Core::None ? [] : [1, :dim, "defaults to: ", :bold, kwd.default.inspect]
+        self << [indent, color, short, kwd.name.to_s, ": ", vcolor, "<value>", :reset, 1, kwd.desc, *default] 
+      end
+
+      def add_line(*chunks)
+        self << chunks
+      end
+
+      def add_section(text, indent: 1, color: [:bold, :green])
+        self << [nil, indent, color, text]
+      end
+
+      def add_usage(name, options:, args:)
+        options = "options" if options == true
+        args = "args" if args == true
+        @__lines__ = [[:bold, name, " ", *_args(options, [:bold, :cyan]), ' ', *_args(args, [:bold, :blue], "...")], *_lines]
+      end
+
+      def lines = _lines.dup.freeze
+
+      private
+      def _args(args, cols, pfx='')
+        case args
+        when nil
+          []
+        when String
+          [cols, pfx, "[", args, "]", :reset]
+        else
+          args
+        end
+      end
+
+      def _lines =  @__lines__ ||= []
+
+
+      def <<(*line)
+        _lines << [nil, *line.flatten, :reset]
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/opt_parser/flag.rb

@@ -1,32 +1,26 @@
 # frozen_string_literal: true
+
+require 'l43/open_object'
 module L43
   class OptParser
     class Flag
-      attr_reader :multiple, :name
-
-      def on_multiple(&blk)
-        @on_multiple = blk
-        self
-      end
+      extend L43::OpenObject
+      attributes :name, arg_count: 0, as: nil, desc: nil, value: false, short: nil, stop: false
 
-      def update(value, old_value)
-        if old_value && !multiple
-          [:error, "flag :#{name} has already been specified but is not a multiple flag"]
-        elsif multiple
-          [:ok, @on_multiple.(old_value, value)]
+      def count_ok
+        if arg_count.zero?
+          :ok
         else
-          [:ok, true]
+          [:error, "flag #{name} cannot be set multiple times"]
         end
       end
 
-      private
-      def initialize(name, multiple: false)
-        @name = name
-        @multiple = multiple
-        on_multiple do |old, value|
-          old ? old.succ : value
-        end
-      end
+      # def on_multiple(&blk)
+      #   @on_multiple = blk
+      #   self
+      # end
+
+      def real_name = as || name
     end
   end
 end

data/lib/l43/opt_parser/keyword.rb

@@ -1,44 +1,64 @@
 # frozen_string_literal: true
 
+require 'l43/core/enum/hash'
+require 'l43/core/enum/set'
+require 'l43/core/result'
+require 'l43/open_object'
+
+
 module L43
+  module Core::Result
+    def if_error(&blk)
+      return if ok?
+      blk.(self)
+    end
+  end
+
   class OptParser
     class Keyword
-      attr_reader :initializer, :multiple, :name, :type
+      Result = Core::Result
 
-      def on_multiple(&blk)
-        @on_multiple = blk
-        self
-      end
+      extend L43::OpenObject
+      attributes :name,
+        arg_count: 0,
+        as: nil,
+        default: nil,
+        desc: nil,
+        init: nil,
+        multiple: false,
+        set: nil,
+        short: nil,
+        value: nil
 
-      def update(value, old_value)
-        if old_value && !multiple
-          [:error, "keyword #{name} has already been specified but is not a multiple keyword"]
-        elsif old_value
-          value = make_value(value)
-          [:ok, @on_multiple.(old_value, value)]
-        elsif multiple
-          [:ok, [make_value(value)]]
-        else
-          [:ok, make_value(value)]
+      def assign_value(value)
+        if arg_count > 0 && !multiple
+          return Resut.error("must not assign multiple values to keyword #{name}")
         end
+
+        assign_from_set(value).if_error { return it }
+
+        value = init.(value) if init
+        Result.ok(
+          update_attribute(:arg_count, &:succ)
+          .update_attribute(:value, simple_or_multiple(value))
+        )
       end
 
+      def real_name = as || name
+
       private
-      def initialize(name, multiple: false, type: String, &initializer)
-        @initializer = initializer
-        @name = name
-        @multiple = multiple
-        @type = type
-        on_multiple do |old, value|
-          old ? [*old, value] : value
-        end
+      def assign_from_set(value)
+        return Result.ok(value) unless set
+        set
+          .fetch_any(value.to_sym, value.to_s) do
+            "bad value for  keyword #{name}: #{value} (not in set: #{set.keys.inspect})"
+          end
       end
 
-      def make_value(value)
-        value = type.new(value)
-        value = initializer.(value) if initializer
-        multiple
-        value
+      def simple_or_multiple(value)
+        return value unless multiple
+
+        [*Array(self.value), value]
       end
     end
   end

data/lib/l43/opt_parser/memos.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module L43
+  class OptParser
+    module Memos
+      # Compile Time
+      # ------------
+      def aliases = @__aliases__ ||= {}
+      def checks =  @__checks__ ||= []
+      def defaults =  @__defaults__ ||= {}
+      def errors =  @__errors__ ||= []
+      def flags =  @__flags__ ||= {}
+      def hooks =  @__hooks__ ||= []
+      def keywords =  @__keywords__ ||= {}
+
+      # Result
+      # ------
+      def args =  @__args__ ||= []
+      def keywords_values =  @__keywords_values__ ||= {}
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/opt_parser/meta.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'l43/open_object'
+require 'l43/core/none'
+module L43
+  class OptParser
+    module Meta
+      def make_open_object
+        OpenObject.def_class(*undefaulted_kwd_names, **defaulted_kwds_and_flags)
+      end
+
+      private
+      def undefaulted_kwd_names
+        keywords.values.filter_map { it.default == Core::None && it.name } 
+      end
+
+      def defaulted_kwds_and_flags
+        flag_defaults = flags.keys.map { [it, false] }.to_h
+        flag_defaults.merge(defaults)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/opt_parser/version.rb

@@ -2,7 +2,7 @@
 
 module L43
   class OptParser
-    VERSION = '0.0.1'
+    VERSION = '0.2.0'
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/opt_parser.rb

@@ -1,45 +1,144 @@
 # frozen_string_literal: true
 
-require 'ostruct'
+require 'l43/color/colorschemes'
+require 'l43/color/output'
+require 'l43/core/none'
+require 'l43/open_struct'
+require 'l43/open_object'
+
+require_relative 'opt_parser/description'
 require_relative 'opt_parser/errors'
 require_relative 'opt_parser/flag'
 require_relative 'opt_parser/keyword'
+require_relative 'opt_parser/memos'
+require_relative 'opt_parser/meta'
 
 module L43
   class OptParser
 
+    include Color::Output
+    include Core
+    include Memos
+    include Meta
+
+    BadFormat = Class.new(RuntimeError)
+    DuplicateFlagDefinition = Class.new(RuntimeError)
+    DuplicateKwdDefinition = Class.new(RuntimeError)
+    FailedCheck = Class.new(RuntimeError)
+    MissingValue = Class.new(RuntimeError)
+    UndefinedFlag = Class.new(RuntimeError)
+    UndefinedKwd = Class.new(RuntimeError)
+
     FlagRgx = /\A:(.*)/
     KeywordRgx = /(.*):\z/
+    ShortFlagRgx = /\A\-(.*)/
+
+    attr_reader :arguments, :constrained, :description, :kwds_name
 
     # Constraints
     # -----------
-    def flag(name, multiple: false)
-      flags.merge!(symbolize(name) => Flag.new(symbolize(name), multiple:)) { |*|
+    def flag(name, short=nil, **kwds)
+      f = Flag.new(name:, short:, **kwds)
+      flags.merge!(name => f) { |*|
         raise DuplicateFlagDefinition, "flag :#{name} is already defined"
       }
+      if short
+        aliases.merge!(short => f)  {|*|
+          raise DuplicateFlagDefinition, "flag :#{short} is already defined"
+        }
+      end
       @constrained = true
+      description.add_flag(f)
       self
     end
 
-    def keyword(name, multiple: false, type: String, &initializer)
-      keywords.merge!(name => Keyword.new(name, multiple:, type:, &initializer)) { |*| 
+
+    def keyword(name, short=nil, as: nil, default: Core::None, **ks, &init)
+      k = Keyword.new(name:, short:, init:, default:, as:, **ks)
+      keywords.merge!(name => k) { |*|
         raise DuplicateKeywordDefinition, "keyword :#{name} is already defined"
       }
+      if short
+        aliases.merge!(short => k)  {|*|
+          raise DuplicateKwdDefinition, "keyword :#{short} is already defined"
+        }
+      end
+      if default != Core::None
+        defaults.merge!((as||name) => default)
+      elsif k.multiple
+        defaults.merge!((as||name) => [])
+      end
       @constrained = true
+      description.add_kwd(k)
       self
     end
 
+    # Documentation
+    # -------------
+    def add_br
+      description.add_line
+      self
+    end
+
+    def add_desc(*chunks) 
+      description.add_desc(*chunks)
+      self
+    end
+
+    def section(line, indent: 1, color: [:bold, :green])
+      description.add_section(line, indent:, color:)
+      self
+    end
+
+    # Services
+    # --------
+
+    def descriptions = description.lines
+    def help(device: $stderr) = cs_put(descriptions, device:)
+
+
     # Business Logic
     # --------------
     def parse(arguments)
-      reset_data!
       @arguments = arguments
       parse_arguments
 
-      OpenStruct.new(args:, errors:, kwds:, ok?: errors.empty?).freeze
+      return Result.error(errors) unless errors.empty?
+      if constrained
+        mo = make_open_object
+        kwds = mo.new(**defaults.merge(keywords_values))
+        post_checks!(kwds)
+        kwds = run_hooks(kwds)
+        result = OpenStruct.new(kwds_name => kwds, args:, errors:).freeze
+        Result.ok(result)
+      else
+        Result.ok(OpenStruct.new(args:, errors:, kwds: OpenStruct.new(**keywords_values)).freeze)
+      end
+    end
+
+    def post_hook(&blk)
+      hooks << blk
+      self
+    end
+
+    def post_check(name = nil, &blk)
+      checks << [name, blk]
+      self
+    end
+
+    def usage(name, options: nil, args: nil, nls: 0)
+      description.add_usage(name, options:, args:)
+      nls.times { add_br }
     end
 
     private
+    def initialize(with_help: false, kwds_name: :kwds)
+      @kwds_name = kwds_name
+      @description = Description.new
+      if with_help
+        flag(:help, :h, desc: "show this help and exit", stop: true) 
+      end
+    end
     # Permissions
     # -----------
     def allowed_flag?(flag)
@@ -47,31 +146,26 @@ module L43
       flags.fetch(flag, false)
     end
 
-    def allowed_kwd?(kwd)
-      return true unless constrained?
-      keywords.fetch(kwd, false)
-    end
-
-    def check_kwd(kwd, value)
-      return unless constrained?
-    end
-
-
     # Error Handling
     # --------------
-    def add_errors(new_errors) = errors.push(*new_errors)
+    def add_errors(*new_errors)
+      errors.push(*new_errors.flatten)
+      :error
+    end
 
     # Business Logic
     # --------------
-    def assign_kwd(kwd, value)
-      error = check_kwd(kwd, value)
-      return add_errors(error) if error
-      keyword = get_keyword(kwd)
-      case keyword.update(value, kwds[kwd]) 
-      in :ok, value
-        kwds.merge!(kwd => value)
-      in :error, message
-        add_errors(message)
+    def assign_keyword(kwd_sym, value)
+      case get_keyword(kwd_sym)
+      in :error
+        nil
+      in keyword
+        case keyword.assign_value(value)
+        in :error, error
+          nil
+        in :ok, keyword
+          keywords_values.merge!(keyword.real_name => keyword.value)
+        end
       end
     end
 
@@ -79,31 +173,50 @@ module L43
       return value unless constrained?
     end
 
-    def get_flag(flag)
-      flags.fetch(flag) do
-        flags[flag] = Flag.new(flag, multiple: true)
+    def get_flag(flag_sym)
+      flags.fetch(flag_sym) do
+        aliases.fetch(flag_sym) do
+          if constrained?
+            add_errors("undefined flag #{flag_sym}")
+          else
+            flags[flag_sym] = Flag.new(name: flag_sym)
+          end
+        end
       end
     end
 
-    def get_keyword(kwd)
-      keywords.fetch(kwd) do
-        keywords[kwd] = Keyword.new(kwd, multiple: true)
+    def get_keyword(name)
+      keywords.fetch(name) do
+        aliases.fetch(name) do
+          if constrained
+            add_errors("undefined keyword: '#{name}'")
+          else
+            keywords[name] = Keyword.new(name:)
+          end
+        end
       end
     end
 
+    def parse_all_flags(flags)
+      flags.grapheme_clusters.each { parse_flag(it.to_sym) }
+      1
+    end
+
     def parse_argument
-      case @arguments.first
+      case arguments.first
       when nil
         return
       when '::'
-        args.push(*@arguments.drop(1))
+        args.push(*arguments.drop(1))
         return
+      when ShortFlagRgx
+        parse_all_flags($1)
       when FlagRgx
         parse_flag($1.to_sym)
       when KeywordRgx
         parse_kwd($1.to_sym)
       else
-        args << @arguments.first
+        args << arguments.first
         1
       end
     end
@@ -111,51 +224,59 @@ module L43
     def parse_arguments
       loop do
         count = parse_argument
+        # p(args:, arguments:)
         return unless count
         @arguments = @arguments.drop(count)
       end
     end
 
-    def parse_flag(flag)
-      add_errors("undefined flag: :#{flag}") unless allowed_flag?(flag)
-
-      defined_flag = get_flag(flag)
-      case defined_flag.update(1, kwds[flag])
-      in :ok, value
-        kwds.merge!(flag => value)
-      in :error, message
-        add_errors(message)
+    def parse_flag(flag_sym)
+      case get_flag(flag_sym)
+      in :error
+        nil
+      in flag
+        case flag.count_ok
+        in :ok
+          flag = flag
+            .update_attribute(:arg_count, &:succ)
+            .update(value: true)
+          keywords_values.merge!(flag.real_name => true)
+        in :error, error
+          add_errors(error)
+        end
       end
       1
     end
 
-    def parse_kwd(kwd)
-      add_errors("undefined keyword: #{kwd}:") unless allowed_kwd?(kwd)
-        case @arguments
-        in [_]
-          add_errors("keyword #{kwd}: requires value but none was given, make sure there is an argument after '#{kwd}:'")
-        in [_, value, *]
-          assign_kwd(kwd, value)
-        end
+    def parse_kwd(kwd_sym)
+      case @arguments
+      in [_]
+        add_errors("keyword #{kwd_sym}: requires value but none was given, make sure there is an argument after '#{kwd_sym}:'")
+      in [_, value, *]
+        assign_keyword(kwd_sym, value)
+      end
       2
     end
 
+    def post_checks!(keywords)
+      checks.each do |name, check|
+        next if check.(keywords)
+
+        raise FailedCheck, "in postcheck #{name||check.source_location.join(":")}"
+      end
+    end
+
+    def run_hooks(keywords)
+      hooks.inject keywords do |k, hook|
+        hook.(k)
+      end
+    end
+
     def symbolize(name) = name.to_s.gsub("-", "_").to_sym
 
     # Data
     # ----
-    def args =  @__args__ ||= []
     def constrained? = @constrained
-    def errors =  @__errors__ ||= []
-    def kwds =  @__kwds__ ||= {}
-    def flags =  @__flags__ ||= {}
-    def keywords =  @__keywords__ ||= {}
-
-    def reset_data!
-      @__args__ = []
-      @__errors__ = []
-      @__kwds__ = {}
-    end
 
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: l43_opt_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Dober
 bindir: bin
 cert_chain: []
-date: 2026-02-10 00:00:00.000000000 Z
+date: 2026-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -23,6 +23,48 @@ dependencies:
     - - "~>"
       - !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.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: l43_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.8
+- !ruby/object:Gem::Dependency
+  name: l43_open_object
+  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 highly customizable option parser, allowing for different
   option syntax and returning custom classes' instances depending on
@@ -33,9 +75,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/l43/opt_parser.rb
+- lib/l43/opt_parser/description.rb
 - lib/l43/opt_parser/errors.rb
 - lib/l43/opt_parser/flag.rb
 - lib/l43/opt_parser/keyword.rb
+- lib/l43/opt_parser/memos.rb
+- lib/l43/opt_parser/meta.rb
 - lib/l43/opt_parser/version.rb
 homepage: https://codeberg.org/lab419/l43_opt_parser
 licenses:
@@ -48,14 +93,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 4.0.0
+      version: 4.0.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Extract Specs from Markdown
 test_files: []