argvise 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e50f3f629a6b160ae07376bdade25677509ce0b6bb525e62b06170450bb39ea3
-  data.tar.gz: a86b5387f5202ce188b1b652643444f206127eb300bd49661f297faeb820253e
+  metadata.gz: cc2e3625fabe3294535d920c085b82f1c2718032de5f3921a7a9f74424c1ca5f
+  data.tar.gz: 2005628bc2fc53ea8937a310111b4217289051e3c634d5960287ed9e4db4dca0
 SHA512:
-  metadata.gz: 0c261cc3a5591aa7947f496dd60e8caa7ecf45f3b0cb85a6a22a786f0450f4763298963fbe883a7dced42618f6281051e2f6c8b3ad53f6773057cc0c4087de1b
-  data.tar.gz: 124e02d8d29c6b23047bad71b89afc42a78407b1d9e6ec7ca4800c90e8adeacc29989c09b7a83354db4a5b7832d6e809bff88a86950334509ea96a5bfa72502c
+  metadata.gz: 1f78e1ea42b3d355ec65da36c69bbf31b7dfa7386c7483ed42c625ef15dc826f052e7009f040a47ef0f685a2f4d26de347edfeeba9c53c09cdb7941bc5b6915a
+  data.tar.gz: a9c6c99a0590f822f5dda6782a3a12c664008c8eff472c234f004e9b2fb69033e12dba58d8efd6c9bb77ec449cc97dab121cf875e80535f226f0ec29c3aea45c

data/.rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  TargetRubyVersion: 3.1

data/argvise.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'lib/argvise/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'argvise'
+  # spec.version = '0.0.1'
+  spec.version = Argvise::VERSION
+  spec.authors = ['2moe']
+  spec.email = ['m@tmoe.me']
+
+  spec.summary = 'Turns a hash into CLI arguments'
+  spec.description = 'Provides flexible command-line argument generation with support for complex data structures'
+  spec.license = 'Apache-2.0'
+  # spec.extra_rdoc_files = ['docs/rdoc/Readme.rdoc']
+  spec.required_ruby_version = '>= 3.1.0'
+  # spec.metadata['allowed_push_host'] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.homepage = 'https://github.com/2moe/argvise-gem'
+  spec.metadata['homepage_uri'] = spec.homepage
+  # spec.metadata['source_code_uri'] = spec.homepage
+  # spec.metadata['changelog_uri'] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  # gemspec = File.basename(__FILE__)
+  spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, err: IO::NULL) do |ls|
+    ls.readlines("\x0", chomp: true).reject do |f|
+      # (f == gemspec) ||
+      f.start_with?(
+        # bin/ test/ Gemfile Rakefile assets docs/Readme-zh-
+        *%w[
+          spec/ features/ .git .github appveyor
+        ]
+      )
+    end
+  end
+  # spec.bindir = 'exe'
+  # spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/bin/build.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# typed: ignore
+# frozen_string_literal: true
+
+require 'pathname'
+
+Pathname(__dir__ || File.dirname(__FILE__))
+  .parent
+  .then { Dir.chdir(it) }
+
+proj = 'argvise'
+
+system <<~CMD
+  gem uninstall #{proj}
+  gem build #{proj}
+  gem install #{proj}
+CMD
+
+# gem push argvise-*.gem

data/bin/console.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# lib_path = File.expand_path('../lib', __dir__)
+# exec "irb -I #{lib_path} -r argvise"
+
+require 'irb'
+require_relative '../lib/argvise'
+
+puts "Argvise: #{Argvise::VERSION}"
+
+def puts_division_line
+  puts
+  puts '-' * 80
+end
+
+raw_cmd = {
+  compiler: nil,
+  build: nil,
+  pack_type: 'tar+zstd',
+  push: true,
+  v: true,
+  f: 'p2',
+  tag: ['v0.0.1', 'beta'],
+  platform: 'wasi/wasm',
+  label: {
+    maintainer: 'user',
+    description: 'Demo'
+  },
+  "/path/to/dir": nil
+}
+
+puts 'GNU-style + kebab_case_flags(false)'
+raw_cmd
+  .then(&Argvise.new_proc)
+  .with_bsd_style(false)
+  .with_kebab_case_flags(false)
+  .build
+  .display
+
+puts_division_line
+# -----------
+
+puts 'GNU-style + kebab_case_flags(true)'
+raw_cmd
+  .then(&hash_to_argv)
+  .display
+
+puts_division_line
+# -----------
+
+puts 'BSD-style + kebab_case_flags(true)'
+raw_cmd
+  .then(&Argvise.new_proc)
+  .with_bsd_style
+  .with_kebab_case_flags
+  .build
+  .display
+
+puts_division_line
+# -----------
+
+IRB.start

data/docs/Readme.md

@@ -2,40 +2,153 @@
 
 [![Gem Version](https://badge.fury.io/rb/argvise.svg?icon=si%3Arubygems)](https://rubygems.org/gems/argvise)
 
+<!-- [![RubyDoc](https://img.shields.io/badge/-y?label=rubydoc&color=orange)](https://www.rubydoc.info/gems/argvise) -->
+
 A Ruby gem for converting hash structures into command-line argument arrays.
 
 > **Note:** This is *not* a command-line parser — quite the opposite. Argvise helps you **build** CLI commands programmatically.
 
+## Quick Start
+
+```ruby
+# IRB
+system "gem install argvise"
+```
+
+```ruby
+# RUBY
+require 'argvise'
+
+{ cargo: nil, b: nil, r: true, target: "wasm32-wasip2" }
+  .then(&hash_to_argv)
+
+#=> ["cargo", "b", "-r", "--target", "wasm32-wasip2"]
+```
+
+`raw_cmd_hash.then(&hash_to_argv)` is equivalent to:
+
+```ruby
+{ cargo: nil, b: nil, r: true, target: "wasm32-wasip2" }
+  .then(&Argvise.new_proc)
+  .with_bsd_style(false) #=> GNU style
+  .with_kebab_case_flags(true) #=> replace "--cli_flag" with "--cli-flag"
+  .build
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
+# Gemfile
+#
 gem 'argvise'
 ```
 
 And then execute:
 
-```bash
+```sh
+# SHELL
+#
 bundler install
 ```
 
 Or install it directly:
 
-```bash
+```sh
+# SHELL
+#
 gem install argvise
 ```
 
-## Usage
+## Conversion Rules
+
+### Common
+
+| Hash Format             | Result                       |
+| ----------------------- | ---------------------------- |
+| `{ "-k2": nil }`        | `["-k2"]`                    |
+| `{ "--r_a-w_": nil }`   | `["--r_a-w_"]`               |
+| `{ key: nil }`          | `["key"]`                    |
+| `{ key: [] }`           | `[]`                         |
+| `{ key: {} }`           | `[]`                         |
+| `{ key: false }`        | `[]`                         |
+| `{ k: true }`           | `["-k"]`                     |
+| `{ k: "value" }`        | `["-k", "value"]`            |
+| `{ k: ["a", "b"] }`     | `["-k", "a", "-k", "b"]`     |
+| `{ k: { a: 1, b: 2 } }` | `["-k", "a=1", "-k", "b=2"]` |
+
+
+### GNU Style
+
+| Hash Format               | Result                             |
+| ------------------------- | ---------------------------------- |
+| `{ key: true }`           | `["--key"]`                        |
+| `{ key: "value" }`        | `["--key", "value"]`               |
+| `{ key: ["a", "b"] }`     | `["--key", "a", "--key", "b"]`     |
+| `{ key: { a: 1, b: 2 } }` | `["--key", "a=1", "--key", "b=2"]` |
+
+---
+
+#### `with_kebab_case_flags(true)`:
+
+| Hash Format       | Result        |
+| ----------------- | ------------- |
+| `{ key_a: true }` | `["--key-a"]` |
+
+---
+
+#### `with_kebab_case_flags(false)`:
+
+| Hash Format       | Result        |
+| ----------------- | ------------- |
+| `{ key_b: true }` | `["--key_b"]` |
+
+
+### BSD Style
 
-### Basic Conversion
+| Hash Format               | Result                           |
+| ------------------------- | -------------------------------- |
+| `{ key: true }`           | `["-key"]`                       |
+| `{ key: "value" }`        | `["-key", "value"]`              |
+| `{ key: ["a", "b"] }`     | `["-key", "a", "-key", "b"]`     |
+| `{ key: { a: 1, b: 2 } }` | `["-key", "a=1", "-key", "b=2"]` |
+
+---
+
+#### `with_kebab_case_flags(true)`:
+
+| Hash Format       | Result       |
+| ----------------- | ------------ |
+| `{ key_c: true }` | `["-key-c"]` |
+
+---
+
+#### `with_kebab_case_flags(false)`:
+
+| Hash Format       | Result       |
+| ----------------- | ------------ |
+| `{ key_d: true }` | `["-key_d"]` |
+
+
+### Notes
+
+> When the value of a flag key is `nil`, the `kebab_case_flags` option has
+> no effect — i.e., the key will not be transformed.
+>
+> For example, the input `{"a_b-c": nil}` will result in `["a_b-c"]`,
+> and **not** be automatically transformed into `["a-b-c"]`.
+
+## Examples
+
+### Basic Conversion (GNU Style)
 
 ```ruby
 require 'argvise'
 
-options = { 
+raw_cmd_hash = {
   docker: nil,  #=> docker
-  build: nil, 
+  build: nil,
   push: true, #=> --push
   tag: ["ghcr.io/[user]/repo:latest", "ghcr.io/[user]/repo:v0.0.1"], #=> --tag ghcr... --tag ghcr..0.0.1
   platform: "wasi/wasm", #=> --platform wasi/wasm
@@ -47,12 +160,12 @@ options = {
   path: nil,
 }
 
-Argvise.build(options)
+Argvise.build(raw_cmd_hash)
 # => [
-#   "docker", "build", "--push", 
-#   "--tag", "ghcr.io/[user]/repo:latest", "--tag", "ghcr.io/[user]/repo:v0.0.1", 
-#   "--platform", "wasi/wasm", 
-#   "--label", "maintainer=user", "--label", "description=A Docker build example", 
+#   "docker", "build", "--push",
+#   "--tag", "ghcr.io/[user]/repo:latest", "--tag", "ghcr.io/[user]/repo:v0.0.1",
+#   "--platform", "wasi/wasm",
+#   "--label", "maintainer=user", "--label", "description=A Docker build example",
 #   "--file", "wasi.dockerfile", "path"
 # ]
 ```
@@ -64,56 +177,113 @@ Argvise.build(options)
 # => ["-v", "--dir", "/path/to/dir"]
 ```
 
-## Supported Data Structures
+### Configurable builder
 
-### 1. Simple Flags
+> Required
+>   - argvise: >= v0.0.4
+>   - ruby: >= v3.1.0
 
 ```ruby
-{ verbose: true }.then(&hash_to_argv)  # => ["--verbose"]
+raw_cmd = {
+  compiler: nil,
+  build: nil,
+  pack_type: 'tar+zstd',
+  push: true,
+  v: true,
+  f: 'p2',
+  tag: ['v0.0.1', 'beta'],
+  platform: 'wasi/wasm',
+  label: {
+    maintainer: 'user',
+    description: 'Demo'
+  },
+  "/path/to/dir": nil
+}
+
+p '----------------'
+p "GNU-style + kebab case flags=false"
+raw_cmd
+  .then(&Argvise.new_proc)
+  .with_bsd_style(false)
+  .with_kebab_case_flags(false)
+  .build
+  .display
+
+#=> ["compiler", "build", "--pack_type", "tar+zstd", "--push", "-v", "-f", "p2", "--tag", "v0.0.1", "--tag", "beta", "--platform", "wasi/wasm", "--label", "maintainer=user", "--label", "description=Demo", "/path/to/dir"]
+
+p '----------------'
+p 'GNU-style + kebab-case-flags=true'
+raw_cmd
+  .then(&hash_to_argv)
+  .display
+
+#=> ["compiler", "build", "--pack-type", "tar+zstd", "--push", "-v", "-f", "p2", "--tag", "v0.0.1", "--tag", "beta", "--platform", "wasi/wasm", "--label", "maintainer=user", "--label", "description=Demo", "/path/to/dir"]
+
+p '----------------'
+p 'BSD-style + kebab-case-flags=true'
+raw_cmd
+  .then(&Argvise.new_proc)
+  .with_bsd_style
+  .with_kebab_case_flags
+  .build
+  .display
+
+#=> ["compiler", "build", "-pack-type", "tar+zstd", "-push", "-v", "-f", "p2", "-tag", "v0.0.1", "-tag", "beta", "-platform", "wasi/wasm", "-label", "maintainer=user", "-label", "description=Demo", "/path/to/dir"]
 ```
 
-### 2. Boolean Values
+## Data Type
 
-```ruby
-{ silent: false }.then(&hash_to_argv) # => []
-```
+### Boolean
 
-### 3. Array Values
+#### GNU style
 
-```ruby
-{ tag: %w[a b] }.then(&hash_to_argv)
-# => ["--tag", "a", "--tag", "b"]
-```
+- `{ verbose: true }` => "--verbose"
+- `{ v: true }` => "-v"
+- `{ v: false }` => no argument generated
 
-### 4. Hash Values
+#### BSD style
 
-```ruby
-{ label: { env: 'test', k2: 'v2' } }.then(&hash_to_argv)
-# => ["--label", "env=test", "--label", "k2=v2"]
-```
+- `{ verbose: true }` => "-verbose"
+- `{ v: true }` => "-v"
+- `{ v: false }` => no argument generated
 
-## API Documentation
+### String
 
-### `Argvise.build(options)`
+#### GNU style
 
-Main method to convert hash to command-line arguments array
+- `{ f: "a.txt" }` => `["-f", "a.txt"]`
+- `{ file: "a.txt" }` => `["--file", "a.txt"]`
 
-**Parameters:**
+#### BSD style
 
-- `options` (Hash) - The hash to be converted
+- `{ f: "a.txt" }` => `["-f", "a.txt"]`
+- `{ file: "a.txt" }` => `["-file", "a.txt"]`
 
-**Returns:**
+### Array
 
-- Array<String> generated command-line arguments
+#### GNU style
 
-### Conversion Rules
+- `{ t: ["a", "b"] }` => `["-t", "a", "-t", "b"]`
+- `{ tag: %w[a b] }` => `["--tag", "a", "--tag", "b"]`
 
-| Hash Format               | Result Example                     |
-| ------------------------- | ---------------------------------- |
-| `{ key: nil }`            | `["key"]`                          |
-| `{ key: false }`          | `[]`                               |
-| `{ key: true }`           | `["--key"]`                        |
-| `{ k: true }`             | `["-k"]`                           |
-| `{ key: "value" }`        | `["--key", "value"]`               |
-| `{ key: ["a", "b"] }`     | `["--key", "a", "--key", "b"]`     |
-| `{ key: { a: 1, b: 2 } }` | `["--key", "a=1", "--key", "b=2"]` |
+#### BSD style
+
+- `{ t: ["a", "b"] }` => `["-t", "a", "-t", "b"]`
+- `{ tag: %w[a b] }` => `["-tag", "a", "-tag", "b"]`
+
+### Hash
+
+#### GNU style
+
+- `{ e: { profile: 'test', lang: 'C'} }` => `["-e", "profile=test", "-e", "lang=C"]`
+- `{ env: { profile: 'test', lang: 'C'} }` => `["--env", "profile=test", "--env", "lang=C"]`
+
+#### BSD style
+
+- `{ e: { profile: 'test', lang: 'C'} }` => `["-e", "profile=test", "-e", "lang=C"]`
+- `{ env: { profile: 'test', lang: 'C'} }` => `["-env", "profile=test", "-env", "lang=C"]`
+
+## Nil => Raw
+
+- `{ cargo: nil, b: nil}` => `["cargo", "b"]`
+- `{ "-fv": nil}` => `["-fv"]`

data/lib/argvise/version.rb

@@ -1,5 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
 class Argvise
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end

data/lib/argvise.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require_relative 'argvise/version'

data/lib/core.rb

@@ -1,32 +1,163 @@
+# rubocop:disable Style/Lambda, Lint/MissingCopEnableDirective
+# typed: true
 # frozen_string_literal: true
 
-# rubocop:disable Style/Lambda, Lint/MissingCopEnableDirective
 # ------------------
 # Converts hash to command array
 #
-# Example
-#   {cargo: nil, build: nil, v: true, target: "wasm32-wasip2"}.then { Argvise.build _1 }
-#   # Output => ["cargo", "build", "-v", "--target", "wasm32-wasip2"]
+# == Example
+#
+#   { cargo: nil, b: nil, r: true, target: "wasm32-wasip2" }
+#     .then(&Argvise.new_proc)
+#     .with_bsd_style(false)
+#     .build
+#     .display
+#
+#   #=> ["cargo", "b", "-r", "--target", "wasm32-wasip2"]
+#
+# == Conversion Rules:
+#
+# === GNU Style:
+#   - Boolean values:
+#     - `{ verbose: true }` => "--verbose"
+#     - `{ v: true }` => "-v"
+#     - `{ v: false }` => no argument generated
+#   - String values:
+#     - `{ f: "a.txt" }` => ["-f", "a.txt"]
+#     - `{ file: "a.txt" }` => ["--file", "a.txt"]
+#   - Array values:
+#     - `{ t: ["a", "b"] }` => `["-t", "a", "-t", "b"]`
+#     - `{ tag: %w[a b] }` => `["--tag", "a", "--tag", "b"]`
+#   - Hash values:
+#     - `{ L: { env: 'test' } }` => `["-L", "env=test"]`
+#     - `{ label: { env: 'test' } }` => `["--label", "env=test"]`
+#
+# === BSD Style:
+#   - Boolean values:
+#     - `{ verbose: true }` => "-verbose"
+#     - `{ v: true }` => "-v"
+#     - `{ v: false }` => no argument generated
+#   - String values:
+#     - `{ f: "a.txt" }` => ["-f", "a.txt"]
+#     - `{ file: "a.txt" }` => ["-file", "a.txt"]
+#   - Array values:
+#     - `{ t: ["a", "b"] }` => `["-t", "a", "-t", "b"]`
+#     - `{ tag: %w[a b] }` => `["-tag", "a", "-tag", "b"]`
+#   - Hash values:
+#     - `{ L: { env: 'test' } }` => `["-L", "env=test"]`
+#     - `{ label: { env: 'test' } }` => `["-label", "env=test"]`
+#
+# === Common:
+#   - Raw values:
+#   - `{ cargo: nil, b: nil}` => `["cargo", "b"]`
+#   - `{ "-fv": nil}` => `["-fv"]`
 #
-# Supported data structures:
-# - Simple flags: `{ verbose: true }` => "--verbose"
-# - Boolean values: `{ v: false }` => no argument generated
-# - Array values: `{ tag: %w[a b] }` => `["--tag", "a", "--tag", "b"]`
-# - Hash values: `{ label: { env: 'test' } }` => `["--label", "env=test"]`
+# === About kebab_case_flags:
+#   - `with_kebab_case_flags(true)`:
+#     - `{enable_jit: true}` =>
+#         - GNU-style: `["--enable-jit"]`
+#         - BSD-style: `["-enable-jit"]`
+#   - `with_kebab_case_flags(false)`:
+#     - `{enable_jit: true}` =>
+#         - GNU-style: `["--enable_jit"]`
+#         - BSD-style: `["-enable_jit"]`
 class Argvise
-  # Converts a hash into a command-line argument array
+  attr_accessor :bsd_style, :kebab_case_flags
+
+  # v0.0.3 default options
+  DEFAULT_OPTS = { bsd_style: false, kebab_case_flags: true }.freeze
+
+  class << self
+    # Converts a hash into a command-line argument array
+    #
+    # == Example
+    #   require 'argvise'
+    #   cmd = { ruby: nil, r: "argvise", verbose: true, e: true, "puts Argvise::VERSION": nil }
+    #   opts = { bsd_style: false }
+    #   Argvise.build(cmd, opts:)
+    #
+    # == Params
+    #   - raw_cmd_hash [Hash] The hash to be converted (i.e., raw input data)
+    #   - opts [Hash] See also: [self.new]
+    #
+    # == Returns
+    #   [Array<String>] The generated array of command-line arguments
+    def build(
+      raw_cmd_hash,
+      opts: nil
+    )
+      opts ||= DEFAULT_OPTS
+      new(raw_cmd_hash, opts:).build
+    end
+
+    # Returns a Proc that wraps `Argvise.new`, allowing functional-style chaining.
+    #
+    # Useful for transforming a hash of CLI arguments into a command array.
+    #
+    # == Example
+    #
+    #   require 'argvise'
+    #   { ruby: nil, r: "argvise", e: true, "puts Argvise::VERSION": nil }
+    #     .then(&Argvise.new_proc)
+    #     .build
+    #     .then{system *_1}
+    #
+    # > See also: [self.new]
+    def new_proc
+      ->(raw_cmd_hash) do
+        new(raw_cmd_hash)
+      end
+    end
+    # ----
+  end
+
+  # == Example
+  #
+  #   require 'argvise'
+  #   cmd = { ruby: nil, r: "argvise", verbose: true, e: true, "puts Argvise::VERSION": nil }
+  #   opts = Argvise::DEFAULT_OPTS
+  #   Argvise.new(cmd, opts:).build.then{system *_1}
   #
-  # @param options [Hash] The hash to be converted
-  # @return [Array<String>] The generated array of command-line arguments
+  # == opts
+  #   [Hash]: { bsd_style: Boolean, kebab_case_flags: Boolean }
   #
-  # sig { params(options: Hash).returns(T::Array[String]) }
-  def self.build(options)
-    new.build(options)
+  # - When `bsd_style` is set to `false`, the builder operates in **GNU-style mode**,
+  #   which typically uses hyphenated flags.
+  #
+  # - If `kebab_case_flags` is set to `true`, any underscores (`_`) in flag names
+  #   will be automatically converted to hyphens (`-`).
+  #   - For example, a flag like `--enable_jit` will be transformed into `--enable-jit`.
+  #
+  # When the value of a flag key is `nil`, the `kebab_case_flags` option has no effect
+  # — i.e., the key will not be transformed.
+  #
+  # For example, the input `{"a_b-c": nil}` will result in `["a_b-c"]`,
+  # and **not** be automatically transformed into `["a-b-c"]`.
+  #
+  def initialize(
+    raw_cmd_hash,
+    opts: nil
+  )
+    opts = DEFAULT_OPTS.merge(opts || {})
+
+    @raw_cmd_hash = raw_cmd_hash
+    @bsd_style = opts[:bsd_style]
+    @kebab_case_flags = opts[:kebab_case_flags]
+  end
+
+  def with_bsd_style(value = true) # rubocop:disable Style/OptionalBooleanParameter
+    @bsd_style = value
+    self
+  end
+
+  def with_kebab_case_flags(value = true) # rubocop:disable Style/OptionalBooleanParameter
+    @kebab_case_flags = value
+    self
   end
 
-  def build(options)
-    # options.each_pair.flat_map { |k, v| process_pair(k.to_s, v) }
-    options.each_with_object([]) do |(k, v), memo|
+  def build
+    # @raw_cmd_hash.each_pair.flat_map { |k, v| process_pair(k.to_s, v) }
+    @raw_cmd_hash.each_with_object([]) do |(k, v), memo|
       memo.concat(process_pair(k.to_s, v))
     end
   end
@@ -44,13 +175,42 @@ class Argvise
     generate_args(flag, value)
   end
 
-  # Builds the command-line flag prefix (automatically detects short or long options)
+  # Builds the command-line flag prefix (automatically detects short or long raw_cmd_hash)
+  #
+  # GNU Style:
+  #  - short key, e.g., {v: true} => "-v"
+  #  - long key, e.g., {verbose: true} => "--verbose"
+  #
+  # BSD Style:
+  #  - short key, e.g., {verbose: true} => "-verbose"
+  #  - no long key
+  #
+  # @kebab_case_flags==true:
+  #  - "_" => "-"
+  #  - e.g., {enable_jit: true} =>
+  #    - BSD-style: "-enable-jit"
+  #    - GNU-style: "--enable-jit"
   #
-  # short key, e.g., {v: true} => "-v"
-  # long key, e.g., {verbose: true} => "--verbose"
-  def build_flag(key)
-    prefix = key.length == 1 ? '-' : '--'
-    "#{prefix}#{key.tr('_', '-')}"
+  # @kebab_case_flags==false:
+  #  - e.g., {enable_jit: true} =>
+  #    - BSD-style: "-enable_jit"
+  #    - GNU-style: "--enable_jit"
+  def build_flag(key) # rubocop:disable Metrics/MethodLength
+    prefix =
+      if @bsd_style
+        '-'
+      else
+        key.length == 1 ? '-' : '--'
+      end
+
+    flag =
+      if @kebab_case_flags
+        key.tr('_', '-')
+      else
+        key
+      end
+
+    "#{prefix}#{flag}"
   end
 
   # Generates the corresponding argument array based on the value type
@@ -95,12 +255,21 @@ end
 
 # A convenient lambda method: converts a hash into command-line arguments
 #
-# Example：
-#   { v: true, path: '/path/to/dir' }.then(&hash_to_argv) # => ["-v", "--path", "/path/to/dir"]
+# == Example：
+#   { v: true, path: '/path/to/dir' }.then(&hash_to_argv)
+#   #=> ["-v", "--path", "/path/to/dir"]
+#
+# == raw_cmd_hash.then(&hash_to_argv) is equivalent to:
+#
+#  raw_cmd_hash
+#    .then(&Argvise.new_proc)
+#    .with_bsd_style(false)
+#    .with_kebab_case_flags(true)
+#    .build
 #
-# sig { returns(T.proc.params(options: Hash).returns(T::Array[String])) }
+# sig { returns(T.proc.params(raw_cmd_hash: Hash).returns(T::Array[String])) }
 def hash_to_argv
-  ->(options) do
-    Argvise.build(options)
+  ->(raw_cmd_hash) do
+    Argvise.build(raw_cmd_hash)
   end
 end

data/rbi/lib/argvise.rbi

@@ -1,12 +1,35 @@
+# rubocop:disable Style/Documentation, Lint/MissingCopEnableDirective
 # typed: true
 # frozen_string_literal: true
 
 class Argvise
   class << self
-    sig { params(options: Hash).returns(T::Array[String]) }
-    def build(options); end
+    sig do
+      params(
+        raw_cmd_hash: Hash,
+        opts: T.nilable(T::Hash[Symbol, T::Boolean])
+      ).returns(T::Array[String])
+    end
+    def build(raw_cmd_hash, opts: nil); end
   end
+
+  sig do
+    params(
+      raw_cmd_hash: Hash,
+      opts: T.nilable(T::Hash[Symbol, T::Boolean])
+    ).void
+  end
+  def initialize(raw_cmd_hash, opts: nil); end
+
+  sig { params(value: T::Boolean).returns(self) }
+  def with_bsd_style(value = true); end # rubocop:disable Style/OptionalBooleanParameter
+
+  sig { params(value: T::Boolean).returns(self) }
+  def with_kebab_case_flags(value = true); end # rubocop:disable Style/OptionalBooleanParameter
+
+  sig { returns(T::Array[String]) }
+  def build; end
 end
 
-sig { returns(T.proc.params(options: Hash).returns(T::Array[String])) }
+sig { returns(T.proc.params(raw_cmd_hash: T::Hash[T.any(Symbol, String), T.untyped]).returns(T::Array[String])) }
 def hash_to_argv; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: argvise
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - 2moe
@@ -17,7 +17,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rubocop.yml"
 - License
+- argvise.gemspec
+- bin/build.rb
+- bin/console.rb
 - docs/Readme.md
 - lib/argvise.rb
 - lib/argvise/version.rb
@@ -35,14 +39,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Turns a hash into CLI arguments
 test_files: []