simple_input 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d023f4e982fe0d178cb837be8de3962107c1a4a7f47569ee527cb7a650254f36
-  data.tar.gz: 894b4a44bc81b8bd01eec6b8847dde883f1df115161ea7038e16ade3b04f17ba
+  metadata.gz: 067ce86ac266a279491b935536c473fe2b257e9a3cd3556877c7affe2be3311c
+  data.tar.gz: e0f078fa1ee462081ed0d2da0d76f44461b6e90d1d595cf1beea1186574937e6
 SHA512:
-  metadata.gz: 4dbcd11a33cdfd07a39c139a629a2b2753810525dc6318a86a437f585bf3734a3a356511641b8232e23f678959e90c71c0b66bc1ecc3e61bf34685e81cc327da
-  data.tar.gz: 0a47a918d2ee493e27e4f14d20b62c8d6b8989508475ecb6e086903aefe28d5bfeb219f85619c97215d9106afd3536ac52c6f630436c5b349596ca3fd649d8cf
+  metadata.gz: c488763914f58752e2f230e78df81e55bc88b53587218ddfeee91ac855c35ffb18a4c8260911615652c058803fd36acf2ee64a53840b704245af23d9a01da736
+  data.tar.gz: f165c355abc6a8776b38bdbc47f2b35991cee593c8ccc776304fca1cf60260186a8b361b7b559225cd2a080aebf31f4544c7eaf4e70f8f34146b23e2c8609391

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hiroaki Satou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,320 @@
+# Simple Input
+
+this is a simple prompt library for ruby.
+inspired by golang's huh! library's input component.
+https://github.com/charmbracelet/huh
+
+## Requirements
+
+- Ruby 3.4+
+- Bundler
+
+## Installation
+
+```bash
+git clone <this-repo>
+cd simple-input
+bundle install
+```
+
+or
+
+```bash
+gem install simple-input
+```
+
+## Usage
+
+### Basic Input
+
+```ruby
+require_relative 'input'
+
+name = Input.new_input
+             .title('What is your name?')
+             .prompt('> ')
+             .validate(:not_empty)
+             .run
+
+puts "Hello, #{name}!"
+```
+
+### Custom Prompt
+
+```ruby
+email = Input.new_input
+              .title('Enter your email')
+              .prompt('email> ')
+              .validate { |val| val.include?('@') ? nil : 'Please enter a valid email' }
+              .run
+```
+
+### Multiple Validators
+
+Validators run in order. The first error found is displayed.
+
+```ruby
+password = Input.new_input
+                 .title('Create a password')
+                 .prompt('password> ')
+                 .validate(:not_empty)
+                 .validate { |val| val.length < 8 ? 'Must be at least 8 characters' : nil }
+                 .run
+```
+
+### Custom Validator Provider
+
+By default, symbol validators (e.g., `:not_empty`) resolve against `DefaultValidators`. You can swap in your own module with `with_validators`:
+
+```ruby
+module MyValidators
+  module_function
+
+  def email(val)
+    val.match?(/\A[^@\s]+@[^@\s]+\z/) ? nil : 'Invalid email format'
+  end
+
+  def min_length(val)
+    val.length >= 3 ? nil : 'Must be at least 3 characters'
+  end
+end
+
+username = Input.new_input
+                .with_validators(MyValidators)
+                .validate(:min_length)
+                .run
+```
+
+### Validation Types
+
+You can pass validators in three ways:
+
+| Type | Example |
+|------|---------|
+| **Symbol** | `.validate(:not_empty)` - looks up method on the validator provider |
+| **Proc/Lambda** | `.validate(-> (val) { val.empty? ? 'required' : nil })` |
+| **Block** | `.validate { \|val\| val.empty? ? 'required' : nil }` |
+
+Validators are functions that take a `String` and return `nil` (valid) or an error message `String`.
+
+### Value Conversion
+
+Use `convert_func` to transform the input value before it's returned. This is useful for converting strings to integers, floats, arrays, or any other type.
+
+```ruby
+# Convert to integer
+age = Input.new_input
+           .title('How old are you?')
+           .validate(:not_empty)
+           .validate { |val| val.match?(/^\d+$/) ? nil : 'Must be a number' }
+           .convert_func { |val| val.to_i }
+           .run
+
+puts age.class  # => Integer
+```
+
+```ruby
+# Convert to array
+tags = Input.new_input
+            .title('Enter tags (comma-separated)')
+            .convert_func { |val| val.split(',').map(&:strip) }
+            .run
+
+puts tags.inspect  # => ["ruby", "cli", "prompt"]
+```
+
+You can pass a converter in two ways:
+
+| Type | Example |
+|------|---------|
+| **Proc/Lambda** | `.convert_func(-> (val) { val.to_i })` |
+| **Block** | `.convert_func { \|val\| val.to_i }` |
+
+Converters are functions that take a `String` and return any type. Validation happens before conversion.
+
+**Important:** If conversion fails with an exception, an error message will be displayed prompting you to add validation. Always validate input before conversion to prevent errors:
+
+```ruby
+# ❌ Bad - conversion can fail without validation
+age = Input.new_input
+           .convert_func { |val| Integer(val) }  # Raises exception on invalid input
+           .run
+
+# ✅ Good - validate before conversion
+age = Input.new_input
+           .validate(:not_empty)
+           .validate { |val| val.match?(/^\d+$/) ? nil : 'Must be a number' }
+           .convert_func { |val| val.to_i }
+           .run
+```
+
+### Signal Handling
+
+- **Ctrl-C** - Prints `(canceled)` and exits gracefully
+- **Ctrl-D (EOF)** - Returns an empty string
+
+## API
+
+| Method | Description |
+|--------|-------------|
+| `Input.new_input` | Factory method to create a new Input (`.new` is private) |
+| `#title(text)` | Set the title displayed above the prompt |
+| `#prompt(text)` | Set the prompt string (default: `"> "`) |
+| `#validate(validator, &block)` | Add a validator (Symbol, Proc, or block) |
+| `#with_validators(provider)` | Set a custom validator provider module |
+| `#convert_func(converter, &block)` | Set a converter function to transform the input value |
+| `#run` | Start the interactive input loop and return the result |
+
+All methods (except `#run`) return `self` for chaining.
+
+## Complete Example: Area Calculator
+
+Here's a practical example that demonstrates validation, conversion, and dependency injection for testing:
+
+```ruby
+class AreaCalculator
+  def initialize(reader = $stdin, writer = $stdout)
+    @reader = reader
+    @writer = writer
+  end
+
+  # Reusable conversion function
+  def to_number
+    ->(value) do
+      if value.to_i.to_s == value
+        value.to_i
+      elsif value.to_f.to_s == value
+        value.to_f
+      else
+        raise ArgumentError, "Invalid number: #{value}"
+      end
+    end
+  end
+
+  def input_length
+    Input.new_input
+      .send(:with_context, @reader, @writer)
+      .title('What is the length of the room in feet?')
+      .validate { |value| value.to_i > 0 ? nil : 'Length must be a positive number' }
+      .convert_func(to_number)
+      .run
+  end
+
+  def input_width
+    Input.new_input
+      .send(:with_context, @reader, @writer)
+      .title('What is the width of the room in feet?')
+      .validate { |value| value.to_i > 0 ? nil : 'Width must be a positive number' }
+      .convert_func(to_number)
+      .run
+  end
+
+  def calculate_area
+    length = input_length
+    width = input_width
+    area = length * width
+
+    @writer.puts "\nYou entered dimensions of #{length} feet by #{width} feet."
+    @writer.puts "The area is #{area} square feet"
+  end
+end
+```
+
+This example can be tested with RSpec using mocks:
+
+```ruby
+RSpec.describe AreaCalculator do
+  let(:writer) { double('writer') }
+  let(:reader) { double('reader') }
+  subject(:calculator) { AreaCalculator.new(reader, writer) }
+
+  before do
+    allow(writer).to receive(:puts)
+    allow(writer).to receive(:print)
+  end
+
+  it 'returns integer for valid integer input' do
+    allow(reader).to receive(:gets).and_return("10\n")
+
+    result = calculator.input_length
+
+    expect(result).to eq(10)
+  end
+
+  it 'returns float for valid float input' do
+    allow(reader).to receive(:gets).and_return("10.5\n")
+
+    result = calculator.input_length
+
+    expect(result).to eq(10.5)
+  end
+end
+```
+
+See `examples/area_calculator.rb` and `examples/area_calculator_spec.rb` for the complete implementation.
+
+## Running Examples
+
+```bash
+# Basic usage and validation
+ruby examples/basic.rb
+
+# Custom validator providers
+ruby examples/custom_validators.rb
+
+# Value conversion (string to int, array, etc.)
+ruby examples/convert.rb
+
+# Common validation patterns (email, password, range, choice)
+ruby examples/validation_patterns.rb
+
+# Error handling and conversion safety
+ruby examples/error_handling.rb
+
+# Area calculator with numeric conversion (practical example)
+ruby examples/area_calculator.rb
+```
+
+## Testing
+
+```bash
+bundle exec rspec
+```
+
+### Testing with `with_context` (Private Method)
+
+The `Input` class has a private method `with_context(reader, writer)` that allows injecting custom IO objects for testing. Since `new` is also private (enforcing use of `Input.new_input`), tests use `send` to access `with_context`:
+
+```ruby
+def build_input(input_text)
+  reader = StringIO.new(input_text)
+  writer = StringIO.new
+  input = Input.new_input
+  input.send(:with_context, reader, writer)
+  [input, writer]
+end
+
+# Usage in tests
+it 'returns the user input' do
+  input, = build_input("hello\n")
+  result = input.run
+  expect(result).to eq('hello')
+end
+
+it 'shows validation errors' do
+  input, writer = build_input("\nhello\n")
+  result = input.validate(:not_empty).run
+  expect(result).to eq('hello')
+  expect(writer.string).to include('入力してください')
+end
+```
+
+This pattern lets you:
+- Simulate user input via `StringIO` as the reader
+- Capture all terminal output via `StringIO` as the writer
+- Test the full input loop including validation re-prompting without interactive terminal input
+
+
+## License
+
+MIT

data/examples/area_calculator.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/simple_prompt'
+
+# Example: Area Calculator with Input Validation and Conversion
+# This example demonstrates using Input with:
+# - Custom validation for positive numbers
+# - Value conversion from string to integer/float
+# - Reusable conversion function
+
+class AreaCalculator
+  def initialize(reader = $stdin, writer = $stdout)
+    @reader = reader
+    @writer = writer
+  end
+
+  # Conversion function that converts string to appropriate numeric type
+  def to_number
+    ->(value) do
+      if value.to_i.to_s == value
+        value.to_i
+      elsif value.to_f.to_s == value
+        value.to_f
+      else
+        raise ArgumentError, "Invalid number: #{value}"
+      end
+    end
+  end
+
+  def input_length
+    Input.new_input
+      .send(:with_context, @reader, @writer)
+      .title('What is the length of the room in feet?')
+      .validate { |value| value.to_i > 0 ? nil : 'Length must be a positive number' }
+      .convert_func(to_number)
+      .run
+  end
+
+  def input_width
+    Input.new_input
+      .send(:with_context, @reader, @writer)
+      .title('What is the width of the room in feet?')
+      .validate { |value| value.to_i > 0 ? nil : 'Width must be a positive number' }
+      .convert_func(to_number)
+      .run
+  end
+
+  def calculate_area
+    length = input_length
+    width = input_width
+    area = length * width
+
+    @writer.puts "\nYou entered dimensions of #{length} feet by #{width} feet."
+    @writer.puts "The area is"
+    @writer.puts "#{area} square feet"
+    @writer.puts "#{(area * 0.09290304).round(3)} square meters"
+  end
+end
+
+# Run the calculator if this file is executed directly
+if __FILE__ == $PROGRAM_NAME
+  calculator = AreaCalculator.new
+  calculator.calculate_area
+end

data/examples/area_calculator_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../lib/simple_prompt'
+require_relative 'area_calculator'
+
+# Example RSpec tests for area_calculator.rb
+# This demonstrates how to test Input with mocks
+
+RSpec.describe AreaCalculator do
+  let(:writer) { double('writer') }
+  let(:reader) { double('reader') }
+  subject(:calculator) { AreaCalculator.new(reader, writer) }
+
+  before do
+    allow(writer).to receive(:puts)
+    allow(writer).to receive(:print)
+  end
+
+  describe '#input_length' do
+    it 'returns integer for valid integer input' do
+      allow(reader).to receive(:gets).and_return("10\n")
+
+      result = calculator.input_length
+
+      expect(result).to eq(10)
+    end
+
+    it 'returns float for valid float input' do
+      allow(reader).to receive(:gets).and_return("10.5\n")
+
+      result = calculator.input_length
+
+      expect(result).to eq(10.5)
+    end
+  end
+
+  describe '#input_width' do
+    it 'returns integer for valid integer input' do
+      allow(reader).to receive(:gets).and_return("20\n")
+
+      result = calculator.input_width
+
+      expect(result).to eq(20)
+    end
+
+    it 'returns float for valid float input' do
+      allow(reader).to receive(:gets).and_return("20.3\n")
+
+      result = calculator.input_width
+
+      expect(result).to eq(20.3)
+    end
+  end
+end

data/examples/basic.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../input'
+
+# Basic usage - simple text input
+name = Input.new_input
+            .title('What is your name?')
+            .prompt('> ')
+            .validate(:not_empty)
+            .run
+
+puts "Hello, #{name}!"
+
+# With custom validation
+email = Input.new_input
+             .title('Enter your email')
+             .prompt('email> ')
+             .validate { |val| val.include?('@') ? nil : 'Please enter a valid email' }
+             .run
+
+puts "Your email: #{email}"
+
+# Multiple validators
+password = Input.new_input
+                .title('Create a password')
+                .prompt('password> ')
+                .validate(:not_empty)
+                .validate { |val| val.length < 8 ? 'Password must be at least 8 characters' : nil }
+                .run
+
+puts "Password set! (#{password.length} characters)"

data/examples/convert.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../input'
+
+# Convert string to integer with proper validation
+# Validation prevents conversion errors
+age = Input.new_input
+           .title('How old are you?')
+           .prompt('age> ')
+           .validate(:not_empty)
+           .validate { |val| val.match?(/^\d+$/) ? nil : 'Please enter a valid number' }
+           .convert_func { |val| val.to_i }
+           .run
+
+puts "You are #{age} years old (type: #{age.class})"
+
+# Example: Without validation, conversion can fail
+# This will show an error message prompting you to add validation
+puts "\n--- Example of conversion error (try entering 'abc') ---"
+number = Input.new_input
+              .title('Enter a number (without validation)')
+              .prompt('> ')
+              .convert_func { |val| Integer(val) } # Integer() raises exception on invalid input
+              .run
+
+puts "Number: #{number}"
+
+# Convert to uppercase
+name = Input.new_input
+            .title('What is your name?')
+            .prompt('name> ')
+            .validate(:not_empty)
+            .convert_func { |val| val.upcase }
+            .run
+
+puts "Hello, #{name}!"
+
+# Convert to array by splitting
+tags = Input.new_input
+            .title('Enter tags (comma-separated)')
+            .prompt('tags> ')
+            .validate(:not_empty)
+            .convert_func { |val| val.split(',').map(&:strip) }
+            .run
+
+puts "Tags: #{tags.inspect} (type: #{tags.class})"
+
+# Using Proc instead of block
+to_float = proc { |val| val.to_f }
+price = Input.new_input
+             .title('Enter price')
+             .prompt('$')
+             .validate(:not_empty)
+             .validate { |val| val.match?(/^\d+\.?\d*$/) ? nil : 'Please enter a valid price' }
+             .convert_func(to_float)
+             .run
+
+puts "Price: $#{price} (type: #{price.class})"

data/examples/custom_validators.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../input'
+
+# Define a custom validator provider
+module MyValidators
+  module_function
+
+  def email(val)
+    val.match?(/\A[^@\s]+@[^@\s]+\z/) ? nil : 'Invalid email format'
+  end
+
+  def min_length(val)
+    val.length >= 3 ? nil : 'Must be at least 3 characters'
+  end
+end
+
+# Use with_validators to swap in your custom provider
+username = Input.new_input
+                .title('Choose a username')
+                .prompt('>> ')
+                .with_validators(MyValidators)
+                .validate(:min_length)
+                .run
+
+puts "Username: #{username}"
+
+email = Input.new_input
+             .title('Enter your email')
+             .prompt('>> ')
+             .with_validators(MyValidators)
+             .validate(:email)
+             .run
+
+puts "Email: #{email}"

data/examples/error_handling.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../input'
+
+puts "=== Error Handling Example ===\n\n"
+
+# Example 1: Conversion without validation (will show error on invalid input)
+puts "Try entering 'abc' to see the error message:"
+number = Input.new_input
+              .title('Enter a number (no validation)')
+              .prompt('> ')
+              .convert_func { |val| Integer(val) }
+              .run
+
+puts "Number: #{number}\n\n"
+
+# Example 2: Proper validation before conversion
+puts "Now with validation:"
+safe_number = Input.new_input
+                   .title('Enter a number (with validation)')
+                   .prompt('> ')
+                   .validate(:not_empty)
+                   .validate { |val| val.match?(/^-?\d+$/) ? nil : 'Must be a valid integer' }
+                   .convert_func { |val| val.to_i }
+                   .run
+
+puts "Number: #{safe_number}\n\n"
+
+# Example 3: Float conversion with validation
+price = Input.new_input
+             .title('Enter price')
+             .prompt('$')
+             .validate(:not_empty)
+             .validate { |val| val.match?(/^\d+\.?\d*$/) ? nil : 'Must be a valid price (e.g., 10 or 10.99)' }
+             .convert_func { |val| val.to_f }
+             .run
+
+puts "Price: $#{format('%.2f', price)}"

data/examples/validation_patterns.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../input'
+
+puts "=== Validation Patterns Example ===\n\n"
+
+# Pattern 1: Email validation
+email = Input.new_input
+             .title('Enter your email address')
+             .prompt('email> ')
+             .validate(:not_empty)
+             .validate { |val| val.match?(/\A[^@\s]+@[^@\s]+\.[^@\s]+\z/) ? nil : 'Invalid email format' }
+             .run
+
+puts "Email registered: #{email}\n\n"
+
+# Pattern 2: Password with multiple rules
+password = Input.new_input
+                .title('Create a secure password')
+                .prompt('password> ')
+                .validate(:not_empty)
+                .validate { |val| val.length >= 8 ? nil : 'Must be at least 8 characters' }
+                .validate { |val| val.match?(/[A-Z]/) ? nil : 'Must contain at least one uppercase letter' }
+                .validate { |val| val.match?(/[0-9]/) ? nil : 'Must contain at least one number' }
+                .run
+
+puts "Password created! (#{password.length} characters)\n\n"
+
+# Pattern 3: Range validation with conversion
+age = Input.new_input
+           .title('Enter your age')
+           .prompt('age> ')
+           .validate(:not_empty)
+           .validate { |val| val.match?(/^\d+$/) ? nil : 'Must be a number' }
+           .validate { |val| val.to_i.between?(1, 120) ? nil : 'Age must be between 1 and 120' }
+           .convert_func { |val| val.to_i }
+           .run
+
+puts "Age: #{age} (type: #{age.class})\n\n"
+
+# Pattern 4: Choice validation
+choice = Input.new_input
+              .title('Select your preferred language')
+              .prompt('(ruby/python/javascript)> ')
+              .validate(:not_empty)
+              .validate { |val| %w[ruby python javascript].include?(val.downcase) ? nil : 'Must be ruby, python, or javascript' }
+              .convert_func { |val| val.downcase.to_sym }
+              .run
+
+puts "Selected language: #{choice} (type: #{choice.class})"

data/lib/simple_prompt/input.rb

@@ -10,6 +10,7 @@ class Input
 
   ValidatorProc = T.type_alias { T.proc.params(arg0: String).returns(T.nilable(String)) }
   ValidatorType = T.type_alias { T.any(Symbol, ValidatorProc) }
+  ConvertProc = T.type_alias { T.proc.params(arg0: String).returns(T.untyped) }
 
   sig { returns(Input) }
   def self.new_input; new; end
@@ -18,12 +19,13 @@ class Input
 
   sig { void }
   def initialize
-    @reader = T.let($stdin, T.any(IO, StringIO))
-    @writer = T.let($stdout, T.any(IO, StringIO))
+    @reader = T.let($stdin, T.untyped)
+    @writer = T.let($stdout, T.untyped)
     @title = T.let('', String)
     @prompt = T.let('> ', String)
     @validators = T.let([], T::Array[ValidatorProc])
     @validator_provider = T.let(DefaultValidators, T.untyped)
+    @convert_func = T.let(nil, T.nilable(ConvertProc))
   end
 
   sig { params(text: String).returns(T.self_type) }
@@ -35,6 +37,12 @@ class Input
   sig { params(provider: T.untyped).returns(T.self_type) }
   def with_validators(provider); @validator_provider = provider; self; end
 
+  sig { params(converter: T.nilable(ConvertProc), block: T.nilable(ConvertProc)).returns(T.self_type) }
+  def convert_func(converter = nil, &block)
+    @convert_func = block || converter
+    self
+  end
+
   sig { params(validator: T.nilable(ValidatorType), block: T.nilable(ValidatorProc)).returns(T.self_type) }
   def validate(validator = nil, &block)
     if block
@@ -51,7 +59,7 @@ class Input
     self
   end
 
-  sig { returns(String) }
+  sig { returns(T.untyped) }
   def run
     loop do
       @writer.puts "\e[1m#{@title}\e[0m" unless @title.empty?
@@ -64,7 +72,13 @@ class Input
       error = T.let(nil, T.nilable(String))
       @validators.each { |v| break if (error = v.call(val)) }
 
-      return val unless error
+      unless error
+        begin
+          return @convert_func ? @convert_func.call(val) : val
+        rescue StandardError => e
+          error = "Conversion error: #{e.message} (please add validation)"
+        end
+      end
 
       # 視認性のための余白
       @writer.puts ''
@@ -78,6 +92,6 @@ class Input
 
   private
 
-  sig { params(r: T.any(IO, StringIO), w: T.any(IO, StringIO)).returns(T.self_type) }
-  def with_context(r, w); @reader = r; @writer = w; self; end
+  sig { params(reader: T.untyped, writer: T.untyped).returns(T.self_type) }
+  def with_context(reader, writer); @reader = reader; @writer = writer; self; end
 end

data/lib/simple_prompt/version.rb

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

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: simple_input
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Hiroaki Satou
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -93,16 +93,24 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.100
-description: This is a simple prompt library for ruby. Inspired by golang's huh! library's
-  input component (https://github.com/charmbracelet/huh). If somebody needs it, I
-  would make select, multi-select, confirm, text library in addition with AI. But
-  my use case I need input only, so I simply AI tested it only. Not the situation
-  in really use case.
-email: hiroakisatou@example.com
+description: Simple Input provides a fluent API for creating interactive command-line
+  prompts with validation and conversion support. Inspired by golang's huh! library's
+  input component.
+email:
+- ''
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
+- examples/area_calculator.rb
+- examples/area_calculator_spec.rb
+- examples/basic.rb
+- examples/convert.rb
+- examples/custom_validators.rb
+- examples/error_handling.rb
+- examples/validation_patterns.rb
 - lib/simple_prompt.rb
 - lib/simple_prompt/default_validators.rb
 - lib/simple_prompt/input.rb
@@ -111,7 +119,9 @@ homepage: https://github.com/hiroakisatou/simple-prompt
 licenses:
 - MIT
 metadata:
+  homepage_uri: https://github.com/hiroakisatou/simple-prompt
   source_code_uri: https://github.com/hiroakisatou/simple-prompt
+  changelog_uri: https://github.com/hiroakisatou/simple-prompt/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -120,7 +130,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.4'
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -129,5 +139,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
-summary: A simple input library for Ruby
+summary: A simple prompt library for Ruby inspired by golang's huh! library
 test_files: []