argvise 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d63847d3264553ea75e063063330aff39cb7638bb22d4a227664dfef0f55203b
-  data.tar.gz: 44335dc0284501d472b81c9427b939000ade17971d0657727b81cc97a4ad631d
+  metadata.gz: e02579f4619b47f97e46fe3052e577680cd88ba737f742fe581fc55ef7a54527
+  data.tar.gz: '08e79eab0d15b6ec23367d39d23e60dbbc0c969b32e632d6aabb54727136d0c1'
 SHA512:
-  metadata.gz: 331dac661ca76f65e605c027be9217b213a97340530c4d4ebe2871979197f37fef9bb6f0ccfe92034faeeb1b879df1db2a180e932dfb992e6b0ae0b4720a690a
-  data.tar.gz: c00671dfccfba16990b7aff2db61612cbde3ca3b478a6e4b0369181ad6a58aabff3fa28257174bb701fa028b5e6267d227c13b78b85dfc043e8b81309d40de03
+  metadata.gz: 87b6122a07799b34702cdc391d8e9c5219ae93c1380f948d0c7359ec71c94e1256274ee03dfd24becd2b0c91f1f2c6992d3a4c8418333dd0a72d8545099a2cc9
+  data.tar.gz: de14f0f04cace2b164919228c0126692682acfaab406cb710b27828f1db1731f9a59281609cd5c09aab4344e78aa9a11f4f55e2148c0022e404bbd636bf36ccc

data/bin/console.rb

@@ -1,9 +1,12 @@
 #!/usr/bin/env ruby
+# typed: ignore
 # frozen_string_literal: true
 
 # lib_path = File.expand_path('../lib', __dir__)
 # exec "irb -I #{lib_path} -r argvise"
 
+# require "bundler/setup"
+# require "argvise"
 require 'irb'
 require_relative '../lib/argvise'
 
@@ -43,7 +46,7 @@ puts_division_line
 
 puts 'GNU-style + kebab_case_flags(true)'
 raw_cmd
-  .then(&hash_to_argv)
+  .to_argv
   .display
 
 puts_division_line

data/docs/Readme.md

@@ -2,6 +2,8 @@
 
 [![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.
@@ -17,16 +19,21 @@ system "gem install argvise"
 # RUBY
 require 'argvise'
 
-{ cargo: nil, build: nil, v: true, target: "wasm32-wasip2" }
-  .then(&hash_to_argv)
+raw_cmd_hash = {
+  cargo: nil, b: nil, r: true, target: "wasm32-wasip2"
+}
+
+raw_cmd_hash
+  .to_argv
+  # .to_argv({bsd_style: false, kebab_case_flags: true})
 
-#=> ["cargo", "build", "-v", "--target", "wasm32-wasip2"]
+#=> ["cargo", "b", "-r", "--target", "wasm32-wasip2"]
 ```
 
-`raw_cmd_hash.then(&hash_to_argv)` is equivalent to:
+`raw_cmd_hash.to_argv` is equivalent to:
 
 ```ruby
-{ cargo: nil, build: nil, v: true, target: "wasm32-wasip2" }
+raw_cmd_hash
   .then(&Argvise.new_proc)
   .with_bsd_style(false) #=> GNU style
   .with_kebab_case_flags(true) #=> replace "--cli_flag" with "--cli-flag"
@@ -35,6 +42,8 @@ require 'argvise'
 
 ## Installation
 
+### Ruby MRI
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -59,26 +68,31 @@ Or install it directly:
 gem install argvise
 ```
 
+### mruby
+
+[More details](../mruby/Readme.md)
+
 ## Conversion Rules
 
 ### Common
 
-| Hash Format              | Result Example               |
-| ------------------------ | ---------------------------- |
-| `{ key: nil }`           | `["key"]`                    |
-| `{ "-k2": nil }`         | `["-k2"]`                    |
-| `{ "--r_a-nd_om": nil }` | `["--r_a-nd_om"]`            |
-| `{ key: false }`         | `[]`                         |
-| `{ key: [] }`            | `[]`                         |
-| `{ 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"]` |
+| 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 Example                     |
+| Hash Format               | Result                             |
 | ------------------------- | ---------------------------------- |
 | `{ key: true }`           | `["--key"]`                        |
 | `{ key: "value" }`        | `["--key", "value"]`               |
@@ -89,22 +103,22 @@ gem install argvise
 
 #### `with_kebab_case_flags(true)`:
 
-| Hash Format       | Result Example |
-| ----------------- | -------------- |
-| `{ key_a: true }` | `["--key-a"]`  |
+| Hash Format       | Result        |
+| ----------------- | ------------- |
+| `{ key_a: true }` | `["--key-a"]` |
 
 ---
 
 #### `with_kebab_case_flags(false)`:
 
-| Hash Format       | Result Example |
-| ----------------- | -------------- |
-| `{ key_b: true }` | `["--key_b"]`  |
+| Hash Format       | Result        |
+| ----------------- | ------------- |
+| `{ key_b: true }` | `["--key_b"]` |
 
 
 ### BSD Style
 
-| Hash Format               | Result Example                   |
+| Hash Format               | Result                           |
 | ------------------------- | -------------------------------- |
 | `{ key: true }`           | `["-key"]`                       |
 | `{ key: "value" }`        | `["-key", "value"]`              |
@@ -115,17 +129,17 @@ gem install argvise
 
 #### `with_kebab_case_flags(true)`:
 
-| Hash Format       | Result Example |
-| ----------------- | -------------- |
-| `{ key_c: true }` | `["-key-c"]`   |
+| Hash Format       | Result       |
+| ----------------- | ------------ |
+| `{ key_c: true }` | `["-key-c"]` |
 
 ---
 
 #### `with_kebab_case_flags(false)`:
 
-| Hash Format       | Result Example |
-| ----------------- | -------------- |
-| `{ key_d: true }` | `["-key_d"]`   |
+| Hash Format       | Result       |
+| ----------------- | ------------ |
+| `{ key_d: true }` | `["-key_d"]` |
 
 
 ### Notes
@@ -170,7 +184,7 @@ Argvise.build(raw_cmd_hash)
 ### Lambda Shortcut
 
 ```ruby
-{ v: true, dir: '/path/to/dir' }.then(&hash_to_argv)
+{ v: true, dir: '/path/to/dir' }.to_argv
 # => ["-v", "--dir", "/path/to/dir"]
 ```
 
@@ -211,7 +225,7 @@ raw_cmd
 p '----------------'
 p 'GNU-style + kebab-case-flags=true'
 raw_cmd
-  .then(&hash_to_argv)
+  .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"]
@@ -284,3 +298,15 @@ raw_cmd
 
 - `{ cargo: nil, b: nil}` => `["cargo", "b"]`
 - `{ "-fv": nil}` => `["-fv"]`
+
+
+## Changelog
+
+### v0.0.6 (2025-11-05)
+
+Breaking Changes:
+
+- `.hash_to_argv` => `Hash.to_argv(opts)`
+  - i.e.,
+    - old: `{a: true}.then(&hash_to_argv)`
+    - new: `{a: true}.to_argv`

data/lib/argvise/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 class Argvise
-  VERSION = '0.0.4'
+  VERSION = '0.0.6'
 end

data/lib/core.rb

@@ -7,13 +7,13 @@
 #
 # == Example
 #
-#   { cargo: nil, build: nil, v: true, target: "wasm32-wasip2" }
+#   { cargo: nil, b: nil, r: true, target: "wasm32-wasip2" }
 #     .then(&Argvise.new_proc)
 #     .with_bsd_style(false)
 #     .build
 #     .display
 #
-#   #=> ["cargo", "build", "-v", "--target", "wasm32-wasip2"]
+#   #=> ["cargo", "b", "-r", "--target", "wasm32-wasip2"]
 #
 # == Conversion Rules:
 #
@@ -90,6 +90,19 @@ class Argvise
       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)
@@ -99,10 +112,11 @@ class Argvise
   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:)
+  #   Argvise.new(cmd, opts:).build.then{system *_1}
   #
   # == opts
   #   [Hash]: { bsd_style: Boolean, kebab_case_flags: Boolean }
@@ -114,11 +128,11 @@ class Argvise
   #   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"]`.
+  # 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,
@@ -239,23 +253,30 @@ class Argvise
   end
 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"]
-#
-# == 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(raw_cmd_hash: Hash).returns(T::Array[String])) }
-def hash_to_argv
-  ->(raw_cmd_hash) do
-    Argvise.build(raw_cmd_hash)
+class ::Hash # rubocop:disable Style/Documentation
+  # A convenient lambda method: converts a hash into command-line arguments
+  #
+  # == Example：
+  #
+  #   { v: true, path: '/path/to/dir' }.to_argv
+  #   #=> ["-v", "--path", "/path/to/dir"]
+  #
+  # == params:
+  #
+  # - opts: See also [Argvise::new]
+  #
+  # == raw_cmd_hash.to_argv is equivalent to:
+  #
+  #  raw_cmd_hash
+  #    .then(&Argvise.new_proc)
+  #    .with_bsd_style(false)
+  #    .with_kebab_case_flags(true)
+  #    .build
+  #
+  # ---
+  #
+  # sig { params(opts: T.nilable(Hash)).returns(T::Array[String]) }
+  def to_argv(opts = nil)
+    Argvise.build(self, opts: opts)
   end
 end

data/rbi/lib/argvise.rbi

@@ -21,15 +21,17 @@ class Argvise
   end
   def initialize(raw_cmd_hash, opts: nil); end
 
-  sig { params(value: T::Boolean).returns(self) }
+  sig { params(value: T::Boolean).returns(T.self_type) }
   def with_bsd_style(value = true); end # rubocop:disable Style/OptionalBooleanParameter
 
-  sig { params(value: T::Boolean).returns(self) }
+  sig { params(value: T::Boolean).returns(T.self_type) }
   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(raw_cmd_hash: T::Hash[T.any(Symbol, String), T.untyped]).returns(T::Array[String])) }
-def hash_to_argv; end
+class ::Hash
+  sig { params(opts: T.nilable(Hash)).returns(T::Array[String]) }
+  def to_argv(opts = nil); end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: argvise
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - 2moe
@@ -19,7 +19,6 @@ extra_rdoc_files: []
 files:
 - ".rubocop.yml"
 - License
-- argvise.gemspec
 - bin/build.rb
 - bin/console.rb
 - docs/Readme.md
@@ -48,5 +47,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: Turns a hash into CLI arguments
+summary: Converts a hash into CLI arguments [Array]
 test_files: []

data/argvise.gemspec

@@ -1,47 +0,0 @@
-# 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