flagabowski 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd71400c2d0a9dc112f260cf1f444f6382a104bf5d494634365fb9ea7b416fa6
+  data.tar.gz: fe332aecfbf6c5d8ee138274f6c04575f957009704bd2572967522aa09bffc1c
+SHA512:
+  metadata.gz: a869f7020b49edd8d3fbeb3b568c62c6faf6629f98efee0fe54036b1a7420643fa847148c7416c9d2a78bc157f8ee0f667ef2fc2bcb80b1ec0248a478fadce5e
+  data.tar.gz: 76ecdff5dc1ced0e7d661822d05823d4213348d411767ff7d26e39a1e5f2fd26ca06df8c650ad2d96e9a10da869d6b3225b4aa818372333d7b29176133459b50

data/.gitignore

@@ -0,0 +1,38 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+.env
+.byebug_history
+
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+.rvmrc
+
+.rubocop-https?--*

data/.gitlab-ci.yml

@@ -0,0 +1,36 @@
+image: ruby:3.3
+
+stages:
+  - test
+  - release
+
+variables:
+  BUNDLE_PATH: vendor/bundle
+
+cache:
+  paths:
+    - vendor/bundle
+
+before_script:
+  - ruby -v
+  - bundle install --jobs $(nproc)
+
+test:
+  stage: test
+  script:
+    - bundle exec rake spec
+  coverage: '/\d+\.\d+\%/'
+
+release:
+  stage: release
+  only:
+    - tags
+  except:
+    - branches
+  script:
+    - gem build flagabowski.gemspec
+    - export GEM_HOST_API_KEY="${RUBYGEMS_API_KEY}"
+    - gem push flagabowski-*.gem
+  environment:
+    name: production
+    url: https://rubygems.org/gems/flagabowski

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rspec', '~> 3.12'
+  gem 'rake', '~> 13.0'
+end

data/README.md

@@ -0,0 +1,182 @@
+# Flagabowski
+
+Bunny says you're good for it.
+
+A wrapper around Ruby's OptionParser that adds validation, conflict groups, one-of constraints, and automatic short option conflict resolution.
+
+Deeply inspired by [micro-optparse](https://github.com/florianpilz/micro-optparse) but with some additional features.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'flagabowski'
+```
+
+Or install it yourself:
+
+```bash
+gem install flagabowski
+```
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'flagabowski'
+
+parser = Flagabowski::OptionParser.new do |p|
+  p.banner "Usage: myapp [options]"
+
+  p.option name: :get_a_toe,
+           desc: "Get me a toe"
+
+  p.option name: :by,
+           default: "3 o'clock",
+           desc: "You don't want to know how... trust me!"
+
+  p.option name: :dollars,
+           default: 1000000,
+           desc: "amount we thought we were getting"
+end
+
+result = parser.process!(ARGV)
+puts result['get_a_toe']  # true/false
+puts result['by']         # "3 o'clock" or user-provided value
+puts result['dollars']    # 1000000 or user-provided value
+puts result[:pos_args]    # Array of positional arguments
+```
+
+### Required Options
+
+```ruby
+parser.option name: :id,
+              default: '',
+              required: true,
+              desc: "is this your only?"
+
+# Raises OptionParser::MissingArgument if not provided
+```
+
+### Validation with Arrays
+
+```ruby
+parser.option name: :the_money,
+              default: 'ringer',
+              valid: ['ringer', 'ringer for a ringer'],
+              desc: "to be thrown"
+
+# Raises OptionParser::InvalidArgument if value not in array
+```
+
+### Validation with Regex
+
+```ruby
+parser.option name: :email,
+              default: '',
+              valid: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i,
+              desc: "Email address"
+
+# Raises OptionParser::InvalidArgument if value doesn't match regex
+```
+
+### Custom Long and Short Options
+
+```ruby
+parser.option name: :verbose,
+              short: 'x',
+              long: 'debug',
+              desc: "Debug mode"
+
+# Can be invoked with -x or --debug
+```
+
+### Automatic Short Option Conflict Resolution
+
+```ruby
+parser.option name: :verbose, desc: "Verbose output"
+parser.option name: :version, desc: "Show version"
+
+# First option gets -v, second automatically gets -e
+# Both can still use --verbose and --version
+```
+
+### Conflict Groups
+
+Ensure only one option from a group is used:
+
+```ruby
+parser.option name: :json, desc: "JSON output"
+parser.option name: :xml, desc: "XML output"
+parser.option name: :yaml, desc: "YAML output"
+
+parser.add_conflicts_constraint(['json', 'xml', 'yaml'])
+
+# Raises OptionParser::InvalidOption if more than one is provided
+```
+
+### One-Of Groups
+
+Require exactly one option from a group:
+
+```ruby
+parser.option name: :input, default: '', desc: "Input file"
+parser.option name: :stdin, desc: "Read from stdin"
+
+parser.add_one_of_constraint(['input', 'stdin'])
+
+# Raises OptionParser::MissingArgument if neither is provided
+# Raises OptionParser::InvalidOption if both are provided
+```
+
+### Help Text
+
+```ruby
+# Get help text as a string
+help_text = parser.usage
+puts help_text
+```
+
+## Option Parameters
+
+- `name:` (required) - Symbol or string, the option name
+- `desc:` - Description shown in help text (default: "Lazy option authors have failed you.")
+- `default:` - Default value (also determines type casting if `cast:` not specified)
+- `required:` - Boolean, whether option is required (default: false)
+- `valid:` - Array or Regex for validation
+- `short:` - Custom short option letter
+- `long:` - Custom long option name
+- `cast:` - Explicit type to cast to (overrides type inferred from default)
+
+## Type Casting
+
+Types are inferred from the default value, or can be explicitly specified with `cast:`:
+- `default: "text"` → String
+- `default: 42` → Integer
+- `default: nil` → Boolean flag (no argument)
+- `cast: Integer` → Integer (regardless of default)
+- `cast: Float` → Float (can override default's type)
+
+Example with explicit casting:
+```ruby
+parser.option name: :percentage,
+              default: 0,
+              cast: Float,
+              desc: "Percentage as decimal"
+
+# Accepts: --percentage 0.75
+```
+
+## Error Handling
+
+Flagabowski raises standard OptionParser exceptions:
+- `OptionParser::MissingArgument` - Required option not provided, or no option from one-of group
+- `OptionParser::InvalidArgument` - Validation failed
+- `OptionParser::InvalidOption` - Conflicting options used, or multiple from one-of group
+- `OptionParser::ParseError` - General parsing errors (base class)
+
+## License
+
+GPLv2

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc 'Tag the current commit with the version from gemspec and push'
+task :tag do
+  spec = Gem::Specification.load('flagabowski.gemspec')
+  version = spec.version
+  tag = "v#{version}"
+
+  sh "git tag #{tag}"
+  sh "git push origin #{tag}"
+  puts "Tagged and pushed #{tag}"
+end

data/flagabowski.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = "flagabowski"
+  s.version     = "0.0.4"
+  s.summary     = "Bunny says you're good for it."
+  s.description = "A wrapper around Ruby's OptionParser with validation, conflict groups, and one-of constraints"
+  s.authors     = ["Sam Rowe"]
+  s.email       = "gemspam@samrowe.com"
+  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.homepage    = "https://gitlab.com/srowe/flagabowski"
+  s.license     = "GPL-2.0-or-later"
+  s.required_ruby_version = ">= 2.7.0"
+
+  s.metadata = {
+    "source_code_uri" => "https://gitlab.com/srowe/flagabowski",
+    "bug_tracker_uri" => "https://gitlab.com/srowe/flagabowski/-/issues"
+  }
+end

data/lib/flagabowski.rb

@@ -0,0 +1,214 @@
+require 'shellwords'
+require 'optparse'
+
+module Flagabowski
+  class Option
+    def initialize(opts)
+      @name      = opts[:name]
+      @default   = opts[:default] || nil
+      @desc      = opts[:desc] || "Lazy option authors have failed you."
+      @long      = opts[:long]
+      @opts      = opts #for #cast
+      @required  = opts[:required] || false
+      @satisfied = false
+      @short     = opts[:short]
+      @valid     = opts[:valid]
+    end
+
+    def cast
+      @cast ||= @opts[:cast] || @default.class
+    end
+
+    def default
+      @default
+    end
+
+    def desc
+      @desc
+    end
+
+    def long
+      @long || name
+    end
+
+    def long_arg
+      %Q{--#{long}#{cast_arg}}
+    end
+
+    def name
+      @name.to_s
+    end
+
+    def satisfied!
+      @satisfied = true
+    end
+
+    def satisfied?
+      @satisfied
+    end
+
+    def unsatisfied?
+      @required ? ! @satisfied : false
+    end
+
+    def short
+      @short ||= namechars.first
+    end
+
+    def short_arg
+      %Q{-#{short}#{cast_arg}}
+    end
+
+    def short_try_again
+      # perfect is the enemy of good
+      @short = namechars[namechars.index(short)+1]
+    end
+
+    def validate!(thing)
+      return true if @valid.nil?
+
+      case @valid
+      when Array
+        @valid.include?(thing)
+      when Regexp
+        @valid.match?(thing)
+      else
+        false
+      end
+    end
+
+    private
+
+    def cast_arg
+      return '' if cast.name == 'NilClass' #really again, ruby?
+      %Q{=#{really_ruby}}
+    end
+
+    def namechars
+      name.chars
+    end
+
+    def really_ruby
+      @cast.to_s.sub(/C/,'_C').upcase
+    end
+  end
+
+  class OptionParser
+    def initialize
+      @banner     = ''
+      @conflicts  = [] #array of arrays of conflicting switches: [['morning','evening'],['breakfast','lunch','dinner']]
+      @one_of     = [] #array of arrays where any one of the names satsifies the hoax
+      @options    = []
+      @used_short = {}
+      yield self if block_given?
+    end
+
+    def add_one_of_constraint(arr)
+      @one_of << arr
+    end
+
+    def add_conflicts_constraint(arr)
+      @conflicts << arr
+    end
+
+    def banner(banstr)
+      @banner = banstr
+    end
+
+    def option(opts)
+      @options << Option.new(opts)
+    end
+
+    def process!(args)
+      args   = args.shellsplit if args.is_a?(String)
+      result = {}
+
+      @options.each do |opt|
+        opt.instance_variable_set(:@satisfied, false)
+        result[opt.name] = opt.default
+      end
+
+      option_parser = build_option_parser do |opt, value|
+        unless opt.validate!(value)
+          raise ::OptionParser::InvalidArgument, "Invalid value '#{value}' for option #{opt.long_arg}"
+        end
+        opt.satisfied!
+        result[opt.name] = value
+      end
+
+      option_parser.parse!(args)
+
+      validate_required
+      validate_conflicts
+      validate_one_of
+
+      result[:pos_args] = args
+      result
+    end
+
+    def usage
+      build_option_parser.to_s
+    end
+
+    private
+
+    def build_option_parser(&on_option)
+      fix_shorts
+
+      ::OptionParser.new do |optparser|
+        optparser.banner = @banner if @banner
+
+        optparser.on('-h', '--help', 'Show this help message') { } # No-op to prevent exit
+
+        @options.each do |opt|
+          if opt.cast == NilClass
+            optparser.on(opt.short_arg, opt.long_arg, opt.desc) do |value|
+              on_option.call(opt, value) if on_option
+            end
+          else
+            optparser.on(opt.short_arg, opt.long_arg, opt.cast, opt.desc) do |value|
+              on_option.call(opt, value) if on_option
+            end
+          end
+        end
+      end
+    end
+
+    def validate_required
+      unsatisfied = @options.select(&:unsatisfied?)
+      if unsatisfied.any?
+        missing_names = unsatisfied.map { |opt| opt.long_arg }.join(', ')
+        raise ::OptionParser::MissingArgument, "Missing required options: #{missing_names}"
+      end
+    end
+
+    def validate_conflicts
+      @conflicts.each do |conflict_group|
+        if (satisfied = conflict_group.select { |name| @options.find { |opt| opt.name == name && opt.satisfied? } }).length > 1
+          raise ::OptionParser::InvalidOption, "Conflicting options used: #{satisfied.join(', ')}"
+        end
+      end
+    end
+
+    def validate_one_of
+      @one_of.each do |one_of_group|
+        satisfied_count = one_of_group.count { |name| @options.find { |opt| opt.name == name && opt.satisfied? } }
+        if satisfied_count == 0
+          raise ::OptionParser::MissingArgument, "One of the following options is required: #{one_of_group.join(', ')}"
+        elsif satisfied_count > 1
+          raise ::OptionParser::InvalidOption, "Only one of the following options can be used: #{one_of_group.join(', ')}"
+        end
+      end
+    end
+
+    def fix_shorts
+      @options.each do |opt|
+        while @used_short.keys.include?(opt.short)
+          break if @used_short[opt.short] == opt
+          opt.short_try_again
+        end
+        @used_short[opt.short] = opt
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: flagabowski
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Sam Rowe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-12-10 00:00:00.000000000 Z
+dependencies: []
+description: A wrapper around Ruby's OptionParser with validation, conflict groups,
+  and one-of constraints
+email: gemspam@samrowe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- Gemfile
+- README.md
+- Rakefile
+- flagabowski.gemspec
+- lib/flagabowski.rb
+homepage: https://gitlab.com/srowe/flagabowski
+licenses:
+- GPL-2.0-or-later
+metadata:
+  source_code_uri: https://gitlab.com/srowe/flagabowski
+  bug_tracker_uri: https://gitlab.com/srowe/flagabowski/-/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Bunny says you're good for it.
+test_files: []