simple_input 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d023f4e982fe0d178cb837be8de3962107c1a4a7f47569ee527cb7a650254f36
-  data.tar.gz: 894b4a44bc81b8bd01eec6b8847dde883f1df115161ea7038e16ade3b04f17ba
+  metadata.gz: 7bc4897e13a98263144b74d7f41c52a5551a5fd82137700fc81f7fef5ca27271
+  data.tar.gz: 111cec79eef33fe0c657f79d42a29020b8764880513df2839d676fc926bf96bf
 SHA512:
-  metadata.gz: 4dbcd11a33cdfd07a39c139a629a2b2753810525dc6318a86a437f585bf3734a3a356511641b8232e23f678959e90c71c0b66bc1ecc3e61bf34685e81cc327da
-  data.tar.gz: 0a47a918d2ee493e27e4f14d20b62c8d6b8989508475ecb6e086903aefe28d5bfeb219f85619c97215d9106afd3536ac52c6f630436c5b349596ca3fd649d8cf
+  metadata.gz: f2a86db2a363fdef0d0b75c71b9c9b962af329a171f10ae97879a52950e6a75374ed569645217ec32356ff637f1b34ba085edf242040681be60eeed56635e335
+  data.tar.gz: 6a6b0061f158c692db24a9ab149ad79d71ea0d49adb49f43bef20973299cd40a7b7443962e45bf4ed467418ff1dd1537426362f2ad1031d68124b32f4ef6b803

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,231 @@
+# 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.
+
+## 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
+```
+
+## 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/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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimplePrompt
-  VERSION = '0.1.1'
+  VERSION = '0.2.1'
 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.1
 platform: ruby
 authors:
 - Hiroaki Satou
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -93,16 +93,22 @@ 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/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 +117,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 +128,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 +137,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: []