gflag 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b6dd64910c03b1e5cd62989ce87e7aa68e556ee7343d2db8d0c2291aa1cde82
-  data.tar.gz: bbffe8de70f6293bca22173f996d25053b445e4bbb3637cd4084847af1c618fa
+  metadata.gz: f7d317f6547e1a9178d8caf2ee9df3ff368ea30c350301b8667ef540e80bdbf5
+  data.tar.gz: e8ab6353d8f9eb7b76e5995cd7d08ba7d3f5c298840eed1df957841901fc5b7b
 SHA512:
-  metadata.gz: 500da92250a92c74d46c1691d859c9591c47aca94acbf14bb52513d120d7e9c8a70698d14665ad60eae9aa50f8c22cb1b062d2dbc4f71de13637783d5ead8d96
-  data.tar.gz: ae7eb48ebd7209a536064d0c8484d0bb12ff4687a5a9a4192ddc0fe67266a7828fbf8a6a7c432bb24ccd9d23cb915ab3d7ac7360e1f4cccfa8d6fac0d1a59d58
+  metadata.gz: a4c51e0c4bf8327541f34b811028c666876ab3397f18a90a2673994ed6a8f64d92dc4333821d0d064daa1f25729d0fc2764b08c78fa4435f3596d63f13e7aea0
+  data.tar.gz: c79b1cd84c34a7fb8502345232bde6570eb79948ad99063f12f2de99b6797df9a44ef125c2a4f67ec0fd03a25d4816ff32e07c9573cb029c63f82621e223a0dc

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/lib/gflag/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gflag
+  VERSION = '0.1.1'
+end

data/lib/gflag.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+## `g.rb`: An option parser that's more sophisticated than `-s`
+#
+# Inspired by my feature request (https://bugs.ruby-lang.org/issues/21015),
+# this implements what I wish the `-g` flag in Ruby would be: A fast-and-dirty
+# way to specify command-line-arguments that just populate a corresponding
+# global variable.
+##
+
+## Emulate other `$-x` globals, so you can check for `g`'s inclusion with `$-g`.
+$-g = true
+
+## The list of all global variables that `g` parsed out
+GLOBALS = []
+
+## A singleton method on `GLOBALS` used to validate that all variables that
+# were parsed were expected. Note that because of how `g` works, there's no way
+# to differentiate between `-x` and `--x`, but I've never had that be a problem.
+def GLOBALS.expect!(*allowed)
+  # Delete all leading `-`s that were possibly provided
+  allowed = Array(*allowed).map { _1.sub!(/\A-*/, '') }
+
+  # Find the first disallowed flag, and fail if it exists
+  bad = (self - allowed).first and abort "flag #{bad} is not a recognized flag"
+
+  # Hunky dory!
+end
+
+## Set a global variable to a value. This not only assigns to the actual global
+# variable, but also adds it to the `GLOBALS` array, if it's not already there.
+def GLOBALS.assign(flag, value, orig)
+  flag.tr!('-', '_')
+
+  # Only allow alphanumerics as flags
+  unless flag.match? /\A\p{Alnum}+\z/
+    abort "flag #{orig} is not a valid flag name"
+  end
+
+  # Special case booleans, nil, and integers:
+  value = case value
+          when 'true'    then true
+          when 'false'   then false
+          when 'nil'     then nil
+          when /\A\d+\z/ then Integer value
+          else                value
+          end
+
+  # Add the global variable to `self`
+  (self << flag).uniq!
+
+  # Assign the global variable. Sadly, there's no `global_variable_set`, so we
+  # must use `eval`
+  eval "\$#{flag} = value"
+end
+
+# Handle each argument, extracting the flag, or putting it back and `break`ing if we're done
+while (arg = ARGV.shift)
+  case arg
+  # Negated flags: `--no-foo` is the same as `--foo=false`
+  when /\A--no-([^=]+)\z/
+    GLOBALS.assign($1, false, arg)
+
+  # Special case: `--` on its own is an early break
+  when '--'
+    break
+
+  # long-form flags, both with and without arguments
+  when /\A--([^=]+)\K(=)?/
+    GLOBALS.assign($1, $2 ? $' : true, $`)
+
+  # Shorthand flags
+  when /\A-[^-]/
+    arg = arg.delete_prefix '-'
+
+    while (short = arg.slice! 0)
+      # Shorthand flag is given an argument with `=`
+      if arg.delete_prefix!('=')
+        GLOBALS.assign(short, arg, "-#{short}")
+        break
+      end
+
+      # Shorthand flag is given an integer argument; `=` can be omitted
+      if arg.start_with?(/\d/)
+        unless (arg = Integer(arg, exception: false))
+          abort("integer argument for -#{short} has trailing chars: #{arg}")
+        end
+
+        GLOBALS.assign(short, arg, "-#{short}")
+        break
+      end
+
+      # Everything else is a single-character short string
+      GLOBALS.assign(short, true, "-#{short}")
+    end
+
+  # Everything else is a normal argument, and we stop parsing
+  else
+    ARGV.unshift arg
+    break
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gflag
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - SamW
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2025-10-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 email:
 - mail@sampersand.me
@@ -17,11 +17,13 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- Rakefile
+- lib/gflag.rb
+- lib/gflag/version.rb
 homepage: https://github.com/sampersand/gflag
 licenses:
 - MIT
-metadata:
-  homepage_uri: https://github.com/sampersand/gflag
+metadata: {}
 rdoc_options: []
 require_paths:
 - lib
@@ -36,7 +38,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: Adds a the '-g' flag to ruby, which does rudimentary opt parsing
 test_files: []