argument_parser 0.0.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de34c01a224dda66a54884deaf0818e83855515d33281a8b7191a96e27c8f987
-  data.tar.gz: 8ae1418b2bdeb6c9fb25b339e3cc70e335d91bc42de9871f1e889c789303d1dc
+  metadata.gz: 5422411476cd13036bd0c77fe5d2a7dccdbfda4283c8291b02659277bebd14cd
+  data.tar.gz: 7cbc193dea73812eb5c280c842e79e7af3306a1fd8b4215e6d1ad391c2f3ffc2
 SHA512:
-  metadata.gz: 7ad9f308dd95fceb6bae98c97d65075312fb0133937fd8367ab37d04188ab061d5ae640926f805433f916468ef88adc287ae810bfaf55937b7a35ed0f0cd1683
-  data.tar.gz: 6fb21b3496c06b8ab9ce58ee60071e6f703c0edfbbf371b4d50affb0b73bd1f4ffbfb58706e138e29310a88d359d796dd0485639989c5edd3eda7e718cf494ab
+  metadata.gz: 903fdc56168e1a8f6e82e37c55f94b1bb1605e1d4e5575d6e62975932e7c454f2e48fda27dc5778d68a2666aa25670578e8ec7cfdfbe51947bccffdf43e9733a
+  data.tar.gz: '094e60864b261af857b88cc2bc8687d83325df3a2cc6cbf25804f5ba4984e38ef464033a305f9e35adbdeaa66ca7cf99859840af4d40926db8a5537542718df2'

data/lib/argument_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArgumentParser
-  VERSION = "0.0.0"
+  VERSION = "0.1.1"
 end

data/lib/argument_parser.rb

@@ -3,4 +3,125 @@
 require_relative "argument_parser/version"
 
 module ArgumentParser
+  extend self
+
+  Error           = Class.new(StandardError)
+  SchemaError     = Class.new(Error)
+  MissingArgument = Class.new(Error)
+  InvalidArgument = Class.new(Error)
+
+  class Parser < Data.define(:schema)
+    def parse!(argv = ARGV)
+      i = 0
+
+      args = schema.each_with_object({}) do |rule, result|
+        case rule.kind
+        in :required
+          arg = argv[i]
+          raise MissingArgument, "missing required argument: #{rule.name}" if arg.nil?
+          arg = validate_pattern!(arg, rule.options)
+
+          result[rule.name] = arg
+          i += 1
+        in :optional
+          arg = validate_pattern!(argv[i], rule.options)
+
+          result[rule.name] = arg || rule.options[:default]
+          i += 1 if arg
+        in :rest
+          rest_args = argv.dup[i..] || []
+          validate_size(rest_args, rule.options)
+          rest_args.map! { |it| validate_pattern!(it, rule.options) }
+
+          result[rule.name] = rest_args
+          i = argv.size
+        end
+      end
+
+      argv.shift(i)
+
+      args
+    end
+
+    private
+
+    def validate_pattern!(arg, options)
+      coerced_arg = coerce!(arg, options)
+      return coerced_arg unless options[:pattern]
+      return coerced_arg unless arg
+      return coerced_arg if options[:pattern] === coerced_arg
+
+      raise InvalidArgument, "invalid argument: #{arg}"
+    end
+
+    def validate_size(args, options)
+      if (min = options[:min])
+        raise InvalidArgument, "expected at least #{min} argument(s)" if args.size < min
+      end
+
+      if (max = options[:max])
+        raise InvalidArgument, "expected at most #{max} argument(s)" if args.size > max
+      end
+    end
+
+    def coerce!(arg, options)
+      return arg unless arg
+      return arg unless options[:type]
+
+      if options[:type] == Integer
+        Integer(arg)
+      elsif options[:type] == Float
+        Float(arg)
+      elsif options[:type] == String
+        arg
+      else
+        raise SchemaError, "type not supported: #{options[:type]}"
+      end
+    rescue ArgumentError
+      raise InvalidArgument, "invalid argument: #{arg}"
+    end
+  end
+
+  module Schema
+    class Builder
+      def initialize
+        @current_stage = Schema::RequiredStage.new([])
+      end
+
+      def required(...) = @current_stage = @current_stage.required(...)
+      def optional(...) = @current_stage = @current_stage.optional(...)
+      def rest(...)     = @current_stage = @current_stage.rest(...)
+      def build = @current_stage.build
+    end
+
+    Rule = Data.define(:kind, :name, :options)
+
+    RequiredStage = Data.define(:schema) do
+      def required(name, **opts)
+        self.class.new(schema + [Rule.new(:required, name, opts)])
+      end
+
+      def optional(name, **opts)
+        OptionalStage.new(schema + [Rule.new(:optional, name, opts)])
+      end
+
+      def rest(name, **opts)
+        RestStage.new(schema + [Rule.new(:rest, name, opts)])
+      end
+
+      def build = Parser.new(schema)
+    end
+
+    class OptionalStage < RequiredStage
+      def required(*) = raise SchemaError, "cannot add required arguments after optional/rest"
+      def optional(*) = raise SchemaError, "only one optional argument is allowed"
+    end
+
+    class RestStage < OptionalStage
+      def rest(*) = raise SchemaError, "only one rest argument is allowed"
+    end
+  end
+
+  def schema = Schema::RequiredStage.new([])
+  def build(&block) = Schema::Builder.new.instance_eval(&block).build
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: argument_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Matheus Richard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-16 00:00:00.000000000 Z
+date: 2025-09-17 00:00:00.000000000 Z
 dependencies: []
 description: Parse command line arguments with like you parse options with OptionParser.
 email: