Help mij Ruby code schrijven voor het bouwen van een command line interface (CLI)
description
Met deze prompt kan de gebruiker een op maat gemaakte en efficiënte Ruby CLI ontwikkelen die precies aansluit bij de behoeften van zijn toepassing. Het helpt bij het structureren van commando's, invoerverificatie en robuuste foutafhandeling, wat resulteert in gebruiksvriendelijke en betrouwbare command line tools. Dit is een unieke aanvulling op bestaande prompts omdat het zich richt op de interactie met gebruikers via de command line, iets wat niet eerder in deze categorie behandeld is.
prompt
Help mij Ruby code schrijven om een gebruiksvriendelijke command line interface (CLI) te maken voor mijn toepassing: <beschrijf de functionaliteit van de CLI en wat het moet doen>. G ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een basisvoorbeeld van Ruby-code voor een gebruiksvriendelijke command line interface (CLI) die de commando's list, copy en delete (--force) ondersteunt. Deze code bevat invoervalidatie en eenvoudige foutafhandeling.
```ruby
#!/usr/bin/env ruby
require 'optparse'
require 'fileutils'
# Functie om bestanden te lijst
def list_files(directory)
if Dir.exist?(directory)
puts "Bestanden in #{directory}:"
Dir.entries(directory).each do |entry|
next if entry == '.' || entry == '..'
puts " - #{entry}"
end
else
puts "Fout: Directory '#{directory}' bestaat niet."
end
end
# Functie om bestanden te kopiëren
def copy_file(source, destination)
if File.exist?(source)
begin
FileUtils.cp(source, destination)
puts "Bestand gekopieerd van #{source} naar #{destination}."
rescue StandardError => e
puts "Fout bij kopiëren: #{e.message}"
end
else
puts "Fout: Bronbestand '#{source}' bestaat niet."
end
end
# Functie om bestanden te verwijderen
def delete_file(file, force)
if File.exist?(file)
if force
begin
File.delete(file)
puts "Bestand '#{file}' verwijderd (force)."
rescue StandardError => e
puts "Fout bij verwijderen: #{e.message}"
end
else
puts "Fout: Bestand '#{file}' bestaat niet."
end
else
puts "Fout: Bestand '#{file}' bestaat niet."
end
end
# Parse command line opties
options = {}
parser = OptionParser.new do |opts|
opts.banner = "Gebruik: #{$0} [commando] [opties]"
opts.on("--force", "Forceer verwijdering zonder bevestiging") do
options[:force] = true
end
end
# Verwerk de argumenten
commands = ARGV.dup
begin
parser.parse!(ARGV)
rescue OptionParser::InvalidOption => e
puts e.message
exit
end
# Controle op basis van commando
case commands[0]
when 'list'
directory = commands[1] || '.'
list_files(directory)
when 'copy'
if commands.size < 3
puts "Gebruik: copy <bron> <bestemming>"
else
copy_file(commands[1], commands[2])
end
when 'delete'
if commands.size < 2
puts "Gebruik: delete <bestand> [--force]"
else
file = commands[1]
force = options[:force] || false
delete_file(file, force)
end
else
puts "Onbekend commando. Gebruik 'list', 'copy' of 'delete'."
end
```
**Hoe invoer valideren en foutafhandeling implementeren:**
- **Invoer valideren:**
Controleer of het juiste aantal argumenten is opgegeven voor elk commando. Bijvoorbeeld, voor `copy` moet je zowel bron als bestemming meegeven.
Voor `delete` controleer je of het bestand bestaat voordat je het probeert te verwijderen.
- **Foutafhandeling:**
Gebruik `begin-rescue` blokken om uitzonderingen op te vangen bij bestandsbewerkingen zoals kopiëren en verwijderen.
Geef informatieve foutmeldingen als een bestand of directory niet bestaat, of als er een andere fout optreedt.
Deze basisstructuur kan verder worden uitgebreid met meer functies, uitgebreide validatie, bevestigingsvragen voor verwijderingen, en meer gebruikersvriendelijke prompts.
provider: deepseek
model: deepseek-chat
Zeker, ik help je met het schrijven van een CLI in Ruby. Hier is een complete implementatie:
## Basis CLI Structuur
```ruby
#!/usr/bin/env ruby
# frozen_string_literal: true
require 'fileutils'
require 'optparse'
class FileManagerCLI
def initialize
@options = {}
end
def run
parse_arguments
execute_command
rescue StandardError => e
handle_error(e)
end
private
def parse_arguments
OptionParser.new do |opts|
opts.banner = "Gebruik: filemanager <commando> [opties] [argumenten]"
opts.on("--force", "Forceer actie zonder bevestiging") do
@options[:force] = true
end
opts.on("-h", "--help", "Toon help informatie") do
puts opts
exit
end
end.parse!
end
def execute_command
command = ARGV.shift
case command
when "list"
list_files(ARGV[0] || ".")
when "copy"
validate_arguments(2, "copy vereist bron en doel")
copy_file(ARGV[0], ARGV[1])
when "delete"
validate_arguments(1, "delete vereist een bestandspad")
delete_file(ARGV[0])
else
raise "Onbekend commando: #{command}. Beschikbare commando's: list, copy, delete"
end
end
def list_files(directory)
unless File.directory?(directory)
raise "Directory bestaat niet: #{directory}"
end
puts "Bestanden in #{directory}:"
Dir.foreach(directory) do |file|
next if file.start_with?('.')
puts " - #{file}"
end
end
def copy_file(source, destination)
unless File.exist?(source)
raise "Bronbestand bestaat niet: #{source}"
end
if File.exist?(destination) && !@options[:force]
raise "Doelbestand bestaat al. Gebruik --force om te overschrijven"
end
FileUtils.cp(source, destination)
puts "Gekopieerd: #{source} -> #{destination}"
end
def delete_file(file_path)
unless File.exist?(file_path)
raise "Bestand bestaat niet: #{file_path}"
end
unless @options[:force]
print "Weet je zeker dat je #{file_path} wilt verwijderen? (j/n): "
confirmation = gets.chomp.downcase
unless confirmation == 'j' || confirmation == 'y'
puts "Verwijderen geannuleerd"
return
end
end
FileUtils.rm(file_path)
puts "Verwijderd: #{file_path}"
end
def validate_arguments(required_count, error_message)
if ARGV.size < required_count
raise error_message
end
end
def handle_error(error)
puts "Fout: #{error.message}"
exit 1
end
end
# Start de applicatie
if __FILE__ == $0
FileManagerCLI.new.run
end
```
## Gebruiksvoorbeelden
```bash
# Bestanden lijsten
ruby filemanager.rb list
ruby filemanager.rb list /pad/naar/directory
# Bestanden kopiëren
ruby filemanager.rb copy bron.txt doel.txt
ruby filemanager.rb copy --force bron.txt doel.txt
# Bestanden verwijderen
ruby filemanager.rb delete bestand.txt
ruby filemanager.rb delete --force bestand.txt
```
## Validatie en Foutafhandeling
### 1. Input Validatie
```ruby
def validate_file_exists(path)
unless File.exist?(path)
raise "Bestand niet gevonden: #{path}"
end
end
def validate_directory(path)
unless File.directory?(path)
raise "Geen geldige directory: #{path}"
end
end
```
### 2. Geavanceerde Foutafhandeling
```ruby
def safe_operation
yield
rescue Errno::ENOENT => e
puts "Bestand of directory niet gevonden: #{e.message}"
rescue Errno::EACCES => e
puts "Toegang geweigerd: #{e.message}"
rescue StandardError => e
puts "Onverwachte fout: #{e.message}"
# Log de fout voor debugging
File.open('error.log', 'a') { |f| f.puts("#{Time.now}: #{e.backtrace}") }
end
# Gebruik:
safe_operation do
FileUtils.cp(source, destination)
end
```
### 3. Gebruikersbevestiging
```ruby
def ask_confirmation(question)
print "#{question} (j/n): "
response = gets.chomp.downcase
['j', 'y', 'ja', 'yes'].include?(response)
end
```
## Installatie en Gebruik
1. Sla de code op als `filemanager.rb`
2. Maak het uitvoerbaar: `chmod +x filemanager.rb`
3. Gebruik zoals hierboven getoond
## Extra Tips
- Voeg kleuren toe met de `colorize` gem
- Implementeer een `--verbose` optie voor gedetailleerde output
- Gebruik `FileUtils` voor betrouwbare bestandsoperaties
- Test altijd met niet-bestande bestanden en ongeldige paden
Deze implementatie bevat robuuste foutafhandeling, duidelijke gebruikersfeedback en preventie van onbedoelde bestandsverwijdering door de `--force` optie verplicht te stellen voor overwrites en verwijderingen zonder bevestiging.