Creëer een Ruby CLI-tool voor specifieke taken
description
Met deze prompt kan de gebruiker eenvoudig krachtige en gebruiksvriendelijke Ruby CLI-tools ontwikkelen die perfect aansluiten op hun specifieke taken. Het bespaart ontwikkeltijd en zorgt voor uitbreidbare command line applicaties die voldoen aan professionele standaarden. Dit is nuttig voor iedereen die automatisering of specifieke CLI-interacties wil zonder uitgebreide kennis van CLI-ontwerp.
prompt
Help me een Ruby command line interface (CLI) tool te schrijven die de volgende functionaliteit heeft: <beschrijf de taak of het probleem>. Geef aan welke command l ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een voorstel voor een Ruby CLI-tool die bestanden filtert op basis van een zoekwoord in hun inhoud. Ik zal de command line opties en argumenten uitleggen en een basisstructuur geven die gemakkelijk uitbreidbaar is.
**Functionaliteiten en opties:**
- `--input <bestandsnaam>` of `-i <bestandsnaam>`: geeft de lijst van bestanden of een directory op om te doorzoeken.
- `--keyword <zoekterm>` of `-k <zoekterm>`: zoekwoord dat in de bestanden gezocht wordt.
- `--ignore-case` of `-i`: negeer hoofdlettergebruik bij zoeken.
- Mogelijkheid om meerdere bestanden of directory's te specificeren.
- Uitvoer van de bestanden die het zoekwoord bevatten.
---
### Voorbeeld van een basis Ruby CLI script
```ruby
#!/usr/bin/env ruby
require 'optparse'
# Structuur voor opties
options = {
input_paths: [],
keyword: nil,
ignore_case: false
}
# Opties parser
OptionParser.new do |opts|
opts.banner = "Gebruik: zoek_tool.rb [opties]"
opts.on("-i", "--input PATH", "Bestandsnaam of directory om te doorzoeken (meerdere kunnen gespecificeerd worden)") do |path|
options[:input_paths] << path
end
opts.on("-k", "--keyword ZOEKWOORD", "Zoekwoord om te zoeken in bestanden") do |word|
options[:keyword] = word
end
opts.on("-I", "--ignore-case", "Negeer hoofdlettergebruik bij zoeken") do
options[:ignore_case] = true
end
opts.on("-h", "--help", "Toon deze help message") do
puts opts
exit
end
end.parse!
# Validatie
if options[:input_paths].empty?
puts "Fout: Geen input bestands- of directorypaden opgegeven."
exit 1
end
if options[:keyword].nil?
puts "Fout: Geen zoekwoord opgegeven."
exit 1
end
# Methode om bestanden te lezen en te zoeken
def zoek_in_bestand(bestandsnaam, keyword, ignore_case)
resultaten = []
begin
File.foreach(bestandsnaam) do |line|
line_to_check = ignore_case ? line.downcase : line
zoekterm = ignore_case ? keyword.downcase : keyword
if line_to_check.include?(zoekterm)
resultaten << bestandsnaam
break # Als je alleen wilt weten of het bestand het bevat, break hier
end
end
rescue => e
warn "Kan bestand #{bestandsnaam} niet lezen: #{e.message}"
end
resultaten
end
# Bestanden verwerken
gevonden_bestanden = []
options[:input_paths].each do |pad|
if File.directory?(pad)
Dir.glob("#{pad}/**/*").each do |bestand|
volgende tenzij = File.file?(bestand)
gevonden_bestanden.concat(zoek_in_bestand(bestand, options[:keyword], options[:ignore_case]))
end
elsif File.file?(pad)
gevonden_bestanden.concat(zoek_in_bestand(pad, options[:keyword], options[:ignore_case]))
else
warn "Pad bestaat niet: #{pad}"
end
end
# Resultaten tonen
gevonden_bestanden.uniq!
if gevonden_bestanden.empty?
puts "Geen bestanden gevonden met het zoekwoord '#{options[:keyword]}'."
else
puts "Bestanden die het zoekwoord '#{options[:keyword]}' bevatten:"
gevonden_bestanden.each { |f| puts f }
end
```
---
### Uitleg:
- **Opties** worden via `OptionParser` ingesteld voor gebruiksvriendelijkheid.
- Het script accepteert meerdere input paden (bestanden of directories).
- Het zoekt in elk bestand naar het zoekwoord, met de optie om hoofdletterongevoelig te zoeken.
- Resultaten worden getoond in de terminal.
### Uitbreidbaarheid:
- Mogelijkheid om te zoeken op meerdere zoekwoorden.
- Opties voor het tonen van de regels waarin het zoekwoord voorkomt.
- Exporteren van resultaten naar een bestand.
- Parallel uitvoeren voor snellere verwerking.
---
Heeft u nog verdere wensen of vragen?
provider: deepseek
model: deepseek-chat
Hier is een robuuste Ruby CLI-tool volgens uw specificaties:
```ruby
#!/usr/bin/env ruby
# frozen_string_literal: true
require 'optparse'
require 'pathname'
class ContentFilter
attr_reader :options
def initialize
@options = {
ignore_case: false,
verbose: false
}
end
def parse_arguments(args)
OptionParser.new do |opts|
opts.banner = "Gebruik: #{File.basename(__FILE__)} --input BESTAND --keyword ZOEKTERM [OPTIES]"
opts.on("-i", "--input FILE", "Invoerbestand (verplicht)") do |file|
options[:input_file] = file
end
opts.on("-k", "--keyword KEYWORD", "Zoekterm (verplicht)") do |keyword|
options[:keyword] = keyword
end
opts.on("--ignore-case", "Negeer hoofd-/kleine letters") do
options[:ignore_case] = true
end
opts.on("-v", "--verbose", "Toon uitgebreide output") do
options[:verbose] = true
end
opts.on("-h", "--help", "Toon help informatie") do
puts opts
exit
end
opts.on("--version", "Toon versie informatie") do
puts "Content Filter v1.0.0"
exit
end
end.parse!(args)
validate_arguments!
end
def run
files = find_files
matching_files = filter_files(files)
display_results(matching_files)
end
private
def validate_arguments!
unless options[:input_file] && options[:keyword]
raise OptionParser::MissingArgument, "Zowel --input als --keyword zijn verplicht"
end
unless File.exist?(options[:input_file])
raise ArgumentError, "Bestand niet gevonden: #{options[:input_file]}"
end
end
def find_files
input_path = Pathname.new(options[:input_file])
if File.directory?(input_path)
Dir.glob("#{input_path}/**/*").select { |f| File.file?(f) }
else
[options[:input_file]]
end
end
def filter_files(files)
pattern = build_pattern
files.select do |file|
file_matches?(file, pattern)
end
end
def build_pattern
if options[:ignore_case]
Regexp.new(Regexp.escape(options[:keyword]), Regexp::IGNORECASE)
else
Regexp.new(Regexp.escape(options[:keyword]))
end
end
def file_matches?(file, pattern)
File.open(file, "r:UTF-8") do |f|
f.each_line.any? { |line| line.match?(pattern) }
end
rescue => e
puts "Waarschuwing: Kan bestand niet lezen #{file}: #{e.message}" if options[:verbose]
false
end
def display_results(matching_files)
if matching_files.empty?
puts "Geen bestanden gevonden die voldoen aan de zoekcriteria."
else
puts "Gevonden bestanden:"
matching_files.each { |file| puts " • #{file}" }
puts "\nTotaal: #{matching_files.size} bestand(en)"
end
end
end
if __FILE__ == $0
begin
filter = ContentFilter.new
filter.parse_arguments(ARGV)
filter.run
rescue OptionParser::MissingArgument, ArgumentError => e
puts "Fout: #{e.message}"
puts "Gebruik --help voor meer informatie"
exit 1
rescue => e
puts "Onverwachte fout: #{e.message}"
exit 1
end
end
```
**Gebruiksvoorbeelden:**
```bash
# Basis gebruik
./content_filter.rb --input bestanden/ --keyword "ruby"
# Negeer hoofdletters
./content_filter.rb --input document.txt --keyword "CODE" --ignore-case
# Uitgebreide output
./content_filter.rb --input /pad/naar/files --keyword "zoekterm" --verbose
# Help informatie
./content_filter.rb --help
```
**Belangrijke kenmerken:**
1. **Verplichte opties**: `--input` en `--keyword` zijn verplicht
2. **Case-insensitive zoeken**: Met `--ignore-case` optie
3. **Directory ondersteuning**: Werkt met zowel bestanden als mappen
4. **Foutafhandeling**: Duidelijke foutmeldingen en help informatie
5. **UTF-8 ondersteuning**: Correcte encoding afhandeling
6. **Uitbreidbaar**: Modulaire structuur voor toekomstige features
7. **Verbose mode**: Gedetailleerde output met `--verbose`
**Best practices geïmplementeerd:**
- OptionParser voor CLI argument parsing
- Exception handling met duidelijke foutmeldingen
- Modulaire code structuur
- Documentatie via help optie
- UTF-8 encoding support
- Recursieve directory scanning
- Uitgebreide validatie van input
Om het script uitvoerbaar te maken:
```bash
chmod +x content_filter.rb
```