From bc44d01ed4982b484e4f9fcc8867371b875e7e0e Mon Sep 17 00:00:00 2001 From: christopher Date: Fri, 3 Oct 2025 07:40:44 -0300 Subject: [PATCH] =?UTF-8?q?Documenta=C3=A7=C3=A3o=20Keywords?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/keywords/PROMPT.md | 201 +++++++++++++++ docs/keywords/format.md | 446 ++++++++++++++++++++++++++++++---- docs/keywords/last.md | 348 ++++++++++++++++++++++++++ src/services/keywords/last.rs | 230 +++++++++++++++++- 4 files changed, 1174 insertions(+), 51 deletions(-) create mode 100644 docs/keywords/PROMPT.md create mode 100644 docs/keywords/last.md diff --git a/docs/keywords/PROMPT.md b/docs/keywords/PROMPT.md new file mode 100644 index 0000000..cae6a07 --- /dev/null +++ b/docs/keywords/PROMPT.md @@ -0,0 +1,201 @@ +# Modelo de Prompt para Aprendizado de BASIC em Markdown + +## 🎯 **ESTRUTURA PARA APRENDIZ DE BASIC** + +``` +**CONCEITO BASIC:** +[Nome do conceito ou comando] + +**NÍVEL:** +☐ Iniciante ☐ Intermediário ☐ Avançado + +**OBJETIVO DE APRENDIZADO:** +[O que você quer entender ou criar] + +**CÓDIGO EXEMPLO:** +```basic +[Seu código ou exemplo aqui] +``` + +**DÚVIDAS ESPECÍFICAS:** +- [Dúvida 1 sobre o conceito] +- [Dúvida 2 sobre sintaxe] +- [Dúvida 3 sobre aplicação] + +**CONTEXTO DO PROJETO:** +[Descrição do que está tentando fazer] + +**RESULTADO ESPERADO:** +[O que o código deve fazer] + +**PARTES QUE NÃO ENTENDE:** +- [Trecho específico do código] +- [Mensagem de erro] +- [Lógica confusa] +``` + +--- + +## 📚 **EXEMPLO PRÁTICO: LOOP FOR** + +``` +**CONCEITO BASIC:** +LOOP FOR + +**NÍVEL:** +☒ Iniciante ☐ Intermediário ☐ Avançado + +**OBJETIVO DE APRENDIZADO:** +Entender como criar um contador de 1 a 10 + +**CÓDIGO EXEMPLO:** +```basic +10 FOR I = 1 TO 10 +20 PRINT "Número: "; I +30 NEXT I +``` + +**DÚVIDAS ESPECÍFICAS:** +- O que significa "NEXT I"? +- Posso usar outras letras além de "I"? +- Como fazer contagem regressiva? + +**CONTEXTO DO PROJETO:** +Estou criando um programa que lista números + +**RESULTADO ESPERADO:** +Que apareça: Número: 1, Número: 2, etc. + +**PARTES QUE NÃO ENTENDE:** +- Por que precisa do número 10 na linha 10? +- O que acontece se esquecer o NEXT? +``` + +--- + +## 🛠️ **MODELO PARA RESOLVER ERROS** + +``` +**ERRO NO BASIC:** +[Mensagem de erro ou comportamento estranho] + +**MEU CÓDIGO:** +```basic +[Coloque seu código completo] +``` + +**LINHA COM PROBLEMA:** +[Linha específica onde ocorre o erro] + +**COMPORTAMENTO ESPERADO:** +[O que deveria acontecer] + +**COMPORTAMENTO ATUAL:** +[O que está acontecendo de errado] + +**O QUE JÁ TENTEI:** +- [Tentativa 1 de correção] +- [Tentativa 2] +- [Tentativa 3] + +**VERSÃO DO BASIC:** +[QBASIC, GW-BASIC, FreeBASIC, etc.] +``` + +--- + +## 📖 **MODELO PARA EXPLICAR COMANDOS** + +``` +**COMANDO:** +[Nome do comando - ex: PRINT, INPUT, GOTO] + +**SYNTAX:** +[Como escrever corretamente] + +**PARÂMETROS:** +- Parâmetro 1: [Função] +- Parâmetro 2: [Função] + +**EXEMPLO SIMPLES:** +```basic +[Exemplo mínimo e funcional] +``` + +**EXEMPLO PRÁTICO:** +```basic +[Exemplo em contexto real] +``` + +**ERROS COMUNS:** +- [Erro frequente 1] +- [Erro frequente 2] + +**DICA PARA INICIANTES:** +[Dica simples para não errar] + +**EXERCÍCIO SUGERIDO:** +[Pequeno exercício para praticar] +``` + +--- + +## 🎨 **FORMATAÇÃO MARKDOWN PARA BASIC** + +### **Como documentar seu código em .md:** +```markdown +# [NOME DO PROGRAMA] + +## 🎯 OBJETIVO +[O que o programa faz] + +## 📋 COMO USAR +1. [Passo 1] +2. [Passo 2] + +## 🧩 CÓDIGO FONTE +```basic +[Seu código aqui] +``` + +## 🔍 EXPLICAÇÃO +- **Linha X**: [Explicação] +- **Linha Y**: [Explicação] + +## 🚀 EXEMPLO DE EXECUÇÃO +``` +[Saída do programa] +``` +``` + +--- + +## 🏆 **MODELO DE PROJETO COMPLETO** + +``` +# PROJETO BASIC: [NOME] + +## 📝 DESCRIÇÃO +[Descrição do que o programa faz] + +## 🎨 FUNCIONALIDADES +- [ ] Funcionalidade 1 +- [ ] Funcionalidade 2 +- [ ] Funcionalidade 3 + +## 🧩 ESTRUTURA DO CÓDIGO +```basic +[Seu código organizado] +``` + +## 🎯 APRENDIZADOS +- [Conceito 1 aprendido] +- [Conceito 2 aprendido] + +## ❓ DÚVIDAS PARA EVOLUIR +- [Dúvida para melhorar] +- [O que gostaria de fazer depois] +``` + +gerenerate several examples +for this keyword written in rhai do this only for basic audience: \ No newline at end of file diff --git a/docs/keywords/format.md b/docs/keywords/format.md index 4f84305..fba8055 100644 --- a/docs/keywords/format.md +++ b/docs/keywords/format.md @@ -1,56 +1,402 @@ -**FORMAT FUNCTION - PATTERN REFERENCE** +# 📚 **BASIC LEARNING EXAMPLES - FORMAT Function** -**SYNTAX:** `FORMAT(value, pattern)` +## 🎯 **EXAMPLE 1: BASIC CONCEPT OF FORMAT FUNCTION** -**PATTERN TABLE:** +``` +**BASIC CONCEPT:** +FORMAT FUNCTION - Value formatting -| CATEGORY | PATTERN | OUTPUT EXAMPLE | DESCRIPTION | -|----------|---------|----------------|-------------| -| **DATE** | `yyyy` | 2024 | 4-digit year | -| | `yy` | 24 | 2-digit year | -| | `MM` | 01 | 2-digit month | -| | `M` | 1 | 1-2 digit month | -| | `dd` | 05 | 2-digit day | -| | `d` | 5 | 1-2 digit day | -| **TIME** | `HH` | 14 | 24-hour, 2-digit | -| | `H` | 14 | 24-hour, 1-2 digit | -| | `hh` | 02 | 12-hour, 2-digit | -| | `h` | 2 | 12-hour, 1-2 digit | -| | `mm` | 08 | 2-digit minutes | -| | `m` | 8 | 1-2 digit minutes | -| | `ss` | 09 | 2-digit seconds | -| | `s` | 9 | 1-2 digit seconds | -| | `tt` | PM | AM/PM designator | -| | `t` | P | A/P designator | -| | `fff` | 123 | Milliseconds | -| **CURRENCY** | `C` | $ | Currency symbol | -| | `c` | 123.45 | Currency amount | -| | `N` | 1,234.56 | Number with commas | -| | `n` | 1234.56 | Number without commas | -| | `F` | 123.00 | Fixed decimal | -| | `f` | 123.45 | Float decimal | -| | `0` | 0.00 | Zero placeholder | -| | `#` | #.## | Digit placeholder | -| **NUMERIC** | `0` | 0 | Required digit | -| | `#` | # | Optional digit | -| | `.` | . | Decimal point | -| | `,` | , | Thousands separator | -| | `%` | % | Percentage | -| **TEXT** | `@` | TEXT | Character placeholder | -| | `&` | text | Lowercase text | -| | `>` | TEXT | Uppercase text | -| | `<` | text | Force lowercase | -| | `!` | T | Force uppercase | +**LEVEL:** +☒ Beginner ☐ Intermediate ☐ Advanced -**COMMON COMBINATIONS:** -- `yyyy-MM-dd` → 2024-01-15 -- `MM/dd/yy` → 01/15/24 -- `HH:mm:ss` → 14:30:45 -- `C0.00` → $123.45 -- `N2` → 1,234.56 +**LEARNING OBJECTIVE:** +Understand how to format numbers, dates, and text -**USAGE:** -`FORMAT(123.456, "C2")` → "$123.46" -`FORMAT(NOW(), "yyyy-MM-dd HH:mm")` → "2024-01-15 14:30" -`FORMAT(0.15, "0%")` → "15%" +**CODE EXAMPLE:** +```basic +10 NUMBER = 1234.56 +20 TEXT$ = "John" +30 DATE$ = "2024-03-15 14:30:00" +40 +50 PRINT FORMAT(NUMBER, "n") ' 1234.56 +60 PRINT FORMAT(NUMBER, "F") ' 1234.56 +70 PRINT FORMAT(TEXT$, "Hello @!") ' Hello John! +80 PRINT FORMAT(DATE$, "dd/MM/yyyy") ' 15/03/2024 +``` +**SPECIFIC QUESTIONS:** +- What's the difference between "n" and "F"? +- What does "@" mean in text? +- How to format dates in Brazilian format? + +**PROJECT CONTEXT:** +I need to display data in a nicer way + +**EXPECTED RESULT:** +Values formatted according to the pattern + +**PARTS I DON'T UNDERSTAND:** +- When to use each type of formatting +- How it works internally +``` + +--- + +## 🛠️ **EXAMPLE 2: NUMERIC FORMATTING** + +``` +**BASIC CONCEPT:** +NUMBER FORMATTING + +**LEVEL:** +☒ Beginner ☐ Intermediate ☐ Advanced + +**LEARNING OBJECTIVE:** +Learn to format numbers as currency and with separators + +**CODE EXAMPLE:** +```basic +10 VALUE = 1234567.89 +20 +30 PRINT "Standard: "; FORMAT(VALUE, "n") ' 1234567.89 +40 PRINT "Decimal: "; FORMAT(VALUE, "F") ' 1234567.89 +45 PRINT "Integer: "; FORMAT(VALUE, "f") ' 1234567 +50 PRINT "Percentage: "; FORMAT(0.856, "0%") ' 86% +60 +70 ' Formatting with locale +80 PRINT "Dollar: "; FORMAT(VALUE, "C2[en]") ' $1,234,567.89 +90 PRINT "Real: "; FORMAT(VALUE, "C2[pt]") ' R$ 1.234.567,89 +100 PRINT "Euro: "; FORMAT(VALUE, "C2[fr]") ' €1,234,567.89 +``` + +**SPECIFIC QUESTIONS:** +- What does "C2[pt]" mean? +- How to change decimal places? +- Which locales are available? + +**PROJECT CONTEXT:** +Multi-currency financial system + +**EXPECTED RESULT:** +Numbers formatted according to regional standards + +**PARTS I DON'T UNDERSTAND:** +- Syntax of complex patterns +- Differences between locales +``` + +--- + +## 📖 **EXAMPLE 3: EXPLAINING FORMAT COMMAND** + +``` +**COMMAND:** +FORMAT - Formats values + +**SYNTAX:** +```basic +RESULT$ = FORMAT(VALUE, PATTERN$) +``` + +**PARAMETERS:** +- VALUE: Number, date or text to format +- PATTERN$: String with formatting pattern + +**SIMPLE EXAMPLE:** +```basic +10 PRINT FORMAT(123.45, "n") ' 123.45 +20 PRINT FORMAT("Mary", "Ms. @") ' Ms. Mary +``` + +**PRACTICAL EXAMPLE:** +```basic +10 INPUT "Name: "; NAME$ +20 INPUT "Salary: "; SALARY +30 INPUT "Birth date: "; BIRTH_DATE$ +40 +50 PRINT "Record:" +60 PRINT "Name: "; FORMAT(NAME$, "!") ' UPPERCASE +70 PRINT "Salary: "; FORMAT(SALARY, "C2[en]") ' $1,234.56 +80 PRINT "Birth: "; FORMAT(BIRTH_DATE$, "MM/dd/yyyy") +``` + +**COMMON ERRORS:** +- Using wrong pattern for data type +- Forgetting it returns string +- Formatting date without correct format + +**BEGINNER TIP:** +Test each pattern separately before using in project + +**SUGGESTED EXERCISE:** +Create a bank statement with professional formatting +``` + +--- + +## 🎨 **EXAMPLE 4: DATE AND TIME FORMATTING** + +``` +**BASIC CONCEPT:** +DATE AND TIME FORMATTING + +**LEVEL:** +☐ Beginner ☒ Intermediate ☐ Advanced + +**LEARNING OBJECTIVE:** +Learn all date formatting patterns + +**CODE EXAMPLE:** +```basic +10 DATE$ = "2024-03-15 14:30:25" +20 +30 PRINT "Brazilian: "; FORMAT(DATE$, "dd/MM/yyyy") ' 15/03/2024 +40 PRINT "Complete: "; FORMAT(DATE$, "dd/MM/yyyy HH:mm") ' 15/03/2024 14:30 +50 PRINT "US: "; FORMAT(DATE$, "MM/dd/yyyy") ' 03/15/2024 +60 PRINT "International: "; FORMAT(DATE$, "yyyy-MM-dd") ' 2024-03-15 +70 +80 PRINT "24h Time: "; FORMAT(DATE$, "HH:mm:ss") ' 14:30:25 +90 PRINT "12h Time: "; FORMAT(DATE$, "hh:mm:ss tt") ' 02:30:25 PM +100 PRINT "Long date: "; FORMAT(DATE$, "dd 'of' MMMM 'of' yyyy") +``` + +**SPECIFIC QUESTIONS:** +- What's the difference between HH and hh? +- How to show month name? +- What is "tt"? + +**PROJECT CONTEXT:** +Scheduling system and reports + +**EXPECTED RESULT:** +Dates formatted according to needs + +**PARTS I DON'T UNDERSTAND:** +- All formatting codes +- How milliseconds work +``` + +--- + +## 🏆 **EXAMPLE 5: COMPLETE PROJECT - BANK STATEMENT** + +``` +# BASIC PROJECT: FORMATTED BANK STATEMENT + +## 📝 DESCRIPTION +System that generates bank statement with professional formatting + +## 🎨 FEATURES +- [x] Currency formatting +- [x] Date formatting +- [x] Value alignment + +## 🧩 CODE STRUCTURE +```basic +10 ' Customer data +20 NAME$ = "Carlos Silva" +30 BALANCE = 12567.89 +40 +50 ' Transactions +60 DIM DATES$(3), DESCRIPTIONS$(3), AMOUNTS(3) +70 DATES$(1) = "2024-03-10 09:15:00" : DESCRIPTIONS$(1) = "Deposit" : AMOUNTS(1) = 2000 +80 DATES$(2) = "2024-03-12 14:20:00" : DESCRIPTIONS$(2) = "Withdrawal" : AMOUNTS(2) = -500 +90 DATES$(3) = "2024-03-14 11:30:00" : DESCRIPTIONS$(3) = "Transfer" : AMOUNTS(3) = -150.50 +100 +110 ' Header +120 PRINT FORMAT("BANK STATEMENT", "!") +130 PRINT "Customer: "; FORMAT(NAME$, "&") +140 PRINT "Date: "; FORMAT("2024-03-15 08:00:00", "dd/MM/yyyy HH:mm") +150 PRINT STRING$(40, "-") +160 +170 ' Transactions +180 FOR I = 1 TO 3 +190 FORMATTED_DATE$ = FORMAT(DATES$(I), "dd/MM HH:mm") +200 FORMATTED_AMOUNT$ = FORMAT(AMOUNTS(I), "C2[en]") +210 +220 PRINT FORMATTED_DATE$; " - "; +230 PRINT DESCRIPTIONS$(I); +240 PRINT TAB(30); FORMATTED_AMOUNT$ +250 NEXT I +260 +270 ' Balance +280 PRINT STRING$(40, "-") +290 PRINT "Balance: "; TAB(30); FORMAT(BALANCE, "C2[en]") +``` + +## 🎯 LEARNINGS +- Currency formatting with locale +- Date formatting +- Composition of multiple formats + +## ❓ QUESTIONS TO EVOLVE +- How to perfectly align columns? +- How to format negative numbers in red? +- How to add more locales? +``` + +--- + +## 🛠️ **EXAMPLE 6: TEXT FORMATTING** + +``` +**BASIC CONCEPT:** +STRING/TEXT FORMATTING + +**LEVEL:** +☒ Beginner ☐ Intermediate ☐ Advanced + +**LEARNING OBJECTIVE:** +Learn to use placeholders in text + +**CODE EXAMPLE:** +```basic +10 NAME$ = "Mary" +20 CITY$ = "são paulo" +21 COUNTRY$ = "BRAZIL" +22 AGE = 25 +30 +40 PRINT FORMAT(NAME$, "Hello @!") ' Hello Mary! +50 PRINT FORMAT(NAME$, "Welcome, @") ' Welcome, Mary +60 PRINT FORMAT(CITY$, "City: !") ' City: SÃO PAULO +70 PRINT FORMAT(CITY$, "City: &") ' City: são paulo +80 PRINT FORMAT(COUNTRY$, "Country: &") ' Country: brazil +90 +100 ' Combining with numbers +110 PRINT FORMAT(NAME$, "@ is ") + FORMAT(AGE, "n") + " years old" +120 ' Mary is 25 years old +``` + +**SPECIFIC QUESTIONS:** +- What's the difference between @, ! and &? +- Can I use multiple placeholders? +- How to escape special characters? + +**PROJECT CONTEXT:** +Personalized report generation + +**EXPECTED RESULT:** +Dynamic texts formatted automatically + +**PARTS I DON'T UNDERSTAND:** +- Placeholder limitations +- How to mix different types +``` + +--- + +## 📚 **EXAMPLE 7: PRACTICAL EXERCISES** + +``` +# EXERCISES: PRACTICING WITH FORMAT + +## 🎯 EXERCISE 1 - BASIC +Create a program that formats product prices. + +**SOLUTION:** +```basic +10 DIM PRODUCTS$(3), PRICES(3) +20 PRODUCTS$(1) = "Laptop" : PRICES(1) = 2500.99 +30 PRODUCTS$(2) = "Mouse" : PRICES(2) = 45.5 +40 PRODUCTS$(3) = "Keyboard" : PRICES(3) = 120.75 +50 +60 FOR I = 1 TO 3 +70 PRINT FORMAT(PRODUCTS$(I), "@: ") + FORMAT(PRICES(I), "C2[en]") +80 NEXT I +``` + +## 🎯 EXERCISE 2 - INTERMEDIATE +Make a program that shows dates in different formats. + +**SOLUTION:** +```basic +10 DATE$ = "2024-12-25 20:00:00" +20 +30 PRINT "Christmas: "; FORMAT(DATE$, "dd/MM/yyyy") +40 PRINT "US: "; FORMAT(DATE$, "MM/dd/yyyy") +50 PRINT "Dinner: "; FORMAT(DATE$, "HH'h'mm") +60 PRINT "Formatted: "; FORMAT(DATE$, "dd 'of' MMMM 'of' yyyy 'at' HH:mm") +``` + +## 🎯 EXERCISE 3 - ADVANCED +Create a school report card system with formatting. + +**SOLUTION:** +```basic +10 NAME$ = "ana silva" +20 AVERAGE = 8.75 +21 ATTENDANCE = 0.92 +30 REPORT_DATE$ = "2024-03-15 10:00:00" +40 +50 PRINT FORMAT("SCHOOL REPORT CARD", "!") +60 PRINT "Student: "; FORMAT(NAME$, "&") +70 PRINT "Date: "; FORMAT(REPORT_DATE$, "dd/MM/yyyy") +80 PRINT "Average: "; FORMAT(AVERAGE, "n") +90 PRINT "Attendance: "; FORMAT(ATTENDANCE, "0%") +``` + +## 💡 TIPS +- Always test patterns before using +- Use PRINT to see each formatting result +- Combine simple formats to create complex ones +``` + +--- + +## 🎨 **EXAMPLE 8: COMPLETE REFERENCE GUIDE** + +```markdown +# FORMAT FUNCTION - COMPLETE GUIDE + +## 🎯 OBJECTIVE +Format numbers, dates and text professionally + +## 📋 SYNTAX +```basic +RESULT$ = FORMAT(VALUE, PATTERN$) +``` + +## 🔢 NUMERIC FORMATTING +| Pattern | Example | Result | +|---------|---------|--------| +| "n" | `FORMAT(1234.5, "n")` | 1234.50 | +| "F" | `FORMAT(1234.5, "F")` | 1234.50 | +| "f" | `FORMAT(1234.5, "f")` | 1234 | +| "0%" | `FORMAT(0.85, "0%")` | 85% | +| "C2[en]" | `FORMAT(1234.5, "C2[en]")` | $1,234.50 | +| "C2[pt]" | `FORMAT(1234.5, "C2[pt]")` | R$ 1.234,50 | + +## 📅 DATE FORMATTING +| Code | Meaning | Example | +|------|---------|---------| +| yyyy | 4-digit year | 2024 | +| yy | 2-digit year | 24 | +| MM | 2-digit month | 03 | +| M | 1-2 digit month | 3 | +| dd | 2-digit day | 05 | +| d | 1-2 digit day | 5 | +| HH | 24h hour 2-digit | 14 | +| H | 24h hour 1-2 digit | 14 | +| hh | 12h hour 2-digit | 02 | +| h | 12h hour 1-2 digit | 2 | +| mm | 2-digit minute | 05 | +| m | 1-2 digit minute | 5 | +| ss | 2-digit second | 09 | +| s | 1-2 digit second | 9 | +| tt | AM/PM | PM | +| t | A/P | P | + +## 📝 TEXT FORMATTING +| Placeholder | Function | Example | +|-------------|----------|---------| +| @ | Insert original text | `FORMAT("John", "@")` → John | +| ! | Text in UPPERCASE | `FORMAT("John", "!")` → JOHN | +| & | Text in lowercase | `FORMAT("John", "&")` → john | + +## ⚠️ LIMITATIONS +- Dates must be in "YYYY-MM-DD HH:MM:SS" format +- Very large numbers may have issues +- Supported locales: en, pt, fr, de, es, it +``` + +These examples cover from basic to advanced applications of the FORMAT function! 🚀 \ No newline at end of file diff --git a/docs/keywords/last.md b/docs/keywords/last.md new file mode 100644 index 0000000..9e40ef3 --- /dev/null +++ b/docs/keywords/last.md @@ -0,0 +1,348 @@ +# 📚 **BASIC LEARNING EXAMPLES - LAST Function** + +## 🎯 **EXAMPLE 1: BASIC CONCEPT OF LAST FUNCTION** + +``` +**BASIC CONCEPT:** +LAST FUNCTION - Extract last word + +**LEVEL:** +☒ Beginner ☐ Intermediate ☐ Advanced + +**LEARNING OBJECTIVE:** +Understand how the LAST function extracts the last word from text + +**CODE EXAMPLE:** +```basic +10 PALAVRA$ = "The mouse chewed the clothes" +20 ULTIMA$ = LAST(PALAVRA$) +30 PRINT "Last word: "; ULTIMA$ +``` + +**SPECIFIC QUESTIONS:** +- How does the function know where the last word ends? +- What happens if there are extra spaces? +- Can I use it with numeric variables? + +**PROJECT CONTEXT:** +I'm creating a program that analyzes sentences + +**EXPECTED RESULT:** +Should display: "Last word: clothes" + +**PARTS I DON'T UNDERSTAND:** +- Why are parentheses needed? +- How does the function work internally? +``` + +--- + +## 🛠️ **EXAMPLE 2: SOLVING ERROR WITH LAST** + +``` +**BASIC ERROR:** +"Syntax error" when using LAST + +**MY CODE:** +```basic +10 TEXTO$ = "Good day world" +20 RESULTADO$ = LAST TEXTO$ +30 PRINT RESULTADO$ +``` + +**PROBLEM LINE:** +Line 20 + +**EXPECTED BEHAVIOR:** +Show "world" on screen + +**CURRENT BEHAVIOR:** +Syntax error + +**WHAT I'VE TRIED:** +- Tried without parentheses +- Tried with different quotes +- Tried changing variable name + +**BASIC VERSION:** +QBASIC with Rhai extension + +**CORRECTED SOLUTION:** +```basic +10 TEXTO$ = "Good day world" +20 RESULTADO$ = LAST(TEXTO$) +30 PRINT RESULTADO$ +``` +``` + +--- + +## 📖 **EXAMPLE 3: EXPLAINING LAST COMMAND** + +``` +**COMMAND:** +LAST - Extracts last word + +**SYNTAX:** +```basic +ULTIMA$ = LAST(TEXTO$) +``` + +**PARAMETERS:** +- TEXTO$: String from which to extract the last word + +**SIMPLE EXAMPLE:** +```basic +10 FRASE$ = "The sun is bright" +20 ULTIMA$ = LAST(FRASE$) +30 PRINT ULTIMA$ ' Shows: bright +``` + +**PRACTICAL EXAMPLE:** +```basic +10 INPUT "Enter your full name: "; NOME$ +20 SOBRENOME$ = LAST(NOME$) +30 PRINT "Hello Mr./Mrs. "; SOBRENOME$ +``` + +**COMMON ERRORS:** +- Forgetting parentheses: `LAST TEXTO$` ❌ +- Using with numbers: `LAST(123)` ❌ +- Forgetting to assign to a variable + +**BEGINNER TIP:** +Always use parentheses and ensure content is text + +**SUGGESTED EXERCISE:** +Create a program that asks for a sentence and shows the first and last word +``` + +--- + +## 🎨 **EXAMPLE 4: COMPLETE PROJECT WITH LAST** + +``` +# BASIC PROJECT: SENTENCE ANALYZER + +## 📝 DESCRIPTION +Program that analyzes sentences and extracts useful information + +## 🎨 FEATURES +- [x] Extract last word +- [x] Count words +- [x] Show statistics + +## 🧩 CODE STRUCTURE +```basic +10 PRINT "=== SENTENCE ANALYZER ===" +20 INPUT "Enter a sentence: "; FRASE$ +30 +40 ' Extract last word +50 ULTIMA$ = LAST(FRASE$) +60 +70 ' Count words (simplified) +80 PALAVRAS = 1 +90 FOR I = 1 TO LEN(FRASE$) +100 IF MID$(FRASE$, I, 1) = " " THEN PALAVRAS = PALAVRAS + 1 +110 NEXT I +120 +130 PRINT +140 PRINT "Last word: "; ULTIMA$ +150 PRINT "Total words: "; PALAVRAS +160 PRINT "Original sentence: "; FRASE$ +``` + +## 🎯 LEARNINGS +- How to use LAST function +- How to count words manually +- String manipulation in BASIC + +## ❓ QUESTIONS TO EVOLVE +- How to extract the first word? +- How to handle punctuation? +- How to work with multiple sentences? +``` + +--- + +## 🏆 **EXAMPLE 5: SPECIAL CASES AND TESTS** + +``` +**BASIC CONCEPT:** +SPECIAL CASES OF LAST FUNCTION + +**LEVEL:** +☐ Beginner ☒ Intermediate ☐ Advanced + +**LEARNING OBJECTIVE:** +Understand how LAST behaves in special situations + +**CODE EXAMPLES:** +```basic +' Case 1: Empty string +10 TEXTO$ = "" +20 PRINT LAST(TEXTO$) ' Result: "" + +' Case 2: Single word only +30 TEXTO$ = "Sun" +40 PRINT LAST(TEXTO$) ' Result: "Sun" + +' Case 3: Multiple spaces +50 TEXTO$ = "Hello World " +60 PRINT LAST(TEXTO$) ' Result: "World" + +' Case 4: With tabs and newlines +70 TEXTO$ = "Line1" + CHR$(9) + "Line2" + CHR$(13) +80 PRINT LAST(TEXTO$) ' Result: "Line2" +``` + +**SPECIFIC QUESTIONS:** +- What happens with empty strings? +- How does it work with special characters? +- Is it case-sensitive? + +**PROJECT CONTEXT:** +I need to robustly validate user inputs + +**EXPECTED RESULT:** +Consistent behavior in all cases + +**PARTS I DON'T UNDERSTAND:** +- How the function handles whitespace? +- What are CHR$(9) and CHR$(13)? +``` + +--- + +## 🛠️ **EXAMPLE 6: INTEGRATION WITH OTHER FUNCTIONS** + +``` +**BASIC CONCEPT:** +COMBINING LAST WITH OTHER FUNCTIONS + +**LEVEL:** +☐ Beginner ☒ Intermediate ☐ Advanced + +**LEARNING OBJECTIVE:** +Learn to use LAST in more complex expressions + +**CODE EXAMPLE:** +```basic +10 ' Example 1: With concatenation +20 PARTE1$ = "Programming" +30 PARTE2$ = " in BASIC" +40 FRASE_COMPLETA$ = PARTE1$ + PARTE2$ +50 PRINT LAST(FRASE_COMPLETA$) ' Result: "BASIC" + +60 ' Example 2: With string functions +70 NOME_COMPLETO$ = "Maria Silva Santos" +80 SOBRENOME$ = LAST(NOME_COMPLETO$) +90 PRINT "Mr./Mrs. "; SOBRENOME$ + +100 ' Example 3: In conditional expressions +110 FRASE$ = "The sky is blue" +120 IF LAST(FRASE$) = "blue" THEN PRINT "The last word is blue!" +``` + +**SPECIFIC QUESTIONS:** +- Can I use LAST directly in IF? +- How to combine with LEFT$, RIGHT$, MID$? +- Is there a size limit for the string? + +**PROJECT CONTEXT:** +Creating validations and text processing + +**EXPECTED RESULT:** +Use LAST flexibly in different contexts + +**PARTS I DON'T UNDERSTAND:** +- Expression evaluation order +- Performance with very large strings +``` + +--- + +## 📚 **EXAMPLE 7: PRACTICAL EXERCISES** + +``` +# EXERCISES: PRACTICING WITH LAST + +## 🎯 EXERCISE 1 - BASIC +Create a program that asks for the user's full name and greets using only the last name. + +**SOLUTION:** +```basic +10 INPUT "Enter your full name: "; NOME$ +20 SOBRENOME$ = LAST(NOME$) +30 PRINT "Hello, Mr./Mrs. "; SOBRENOME$; "!" +``` + +## 🎯 EXERCISE 2 - INTERMEDIATE +Make a program that analyzes if the last word of a sentence is "end". + +**SOLUTION:** +```basic +10 INPUT "Enter a sentence: "; FRASE$ +20 IF LAST(FRASE$) = "end" THEN PRINT "Sentence ends with 'end'" ELSE PRINT "Sentence doesn't end with 'end'" +``` + +## 🎯 EXERCISE 3 - ADVANCED +Create a program that processes multiple sentences and shows statistics. + +**SOLUTION:** +```basic +10 DIM FRASES$(3) +20 FRASES$(1) = "The sun shines" +30 FRASES$(2) = "The rain falls" +40 FRASES$(3) = "The wind blows" +50 +60 FOR I = 1 TO 3 +70 PRINT "Sentence "; I; ": "; FRASES$(I) +80 PRINT "Last word: "; LAST(FRASES$(I)) +90 PRINT +100 NEXT I +``` + +## 💡 TIPS +- Always test with different inputs +- Use PRINT for debugging +- Start with simple examples +``` + +--- + +## 🎨 **EXAMPLE 8: MARKDOWN DOCUMENTATION** + +```markdown +# LAST FUNCTION - COMPLETE GUIDE + +## 🎯 OBJECTIVE +Extract the last word from a string + +## 📋 SYNTAX +```basic +RESULTADO$ = LAST(TEXTO$) +``` + +## 🧩 PARAMETERS +- `TEXTO$`: Input string + +## 🔍 BEHAVIOR +- Splits string by spaces +- Returns the last part +- Ignores extra spaces at beginning/end + +## 🚀 EXAMPLES +```basic +10 PRINT LAST("hello world") ' Output: world +20 PRINT LAST("one word") ' Output: word +30 PRINT LAST(" spaces ") ' Output: spaces +``` + +## ⚠️ LIMITATIONS +- Doesn't work with numbers +- Requires parentheses +- Considers only spaces as separators +``` + +These examples cover from the basic concept to practical applications of the LAST function, always focusing on BASIC beginners! 🚀 \ No newline at end of file diff --git a/src/services/keywords/last.rs b/src/services/keywords/last.rs index e806c07..010f022 100644 --- a/src/services/keywords/last.rs +++ b/src/services/keywords/last.rs @@ -3,7 +3,7 @@ use rhai::Engine; pub fn last_keyword(engine: &mut Engine) { engine - .register_custom_syntax(&["LAST", "$expr$"], false, { + .register_custom_syntax(&["LAST", "(", "$expr$", ")"], false, { move |context, inputs| { let input_string = context.eval_expression_tree(&inputs[0])?; let input_str = input_string.to_string(); @@ -20,3 +20,231 @@ pub fn last_keyword(engine: &mut Engine) { }) .unwrap(); } + +#[cfg(test)] +mod tests { + use super::*; + use rhai::{Engine, Scope}; + + #[test] + fn test_last_keyword_basic() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"hello world\")").unwrap(); + assert_eq!(result, "world"); + } + + #[test] + fn test_last_keyword_single_word() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"hello\")").unwrap(); + assert_eq!(result, "hello"); + } + + #[test] + fn test_last_keyword_empty_string() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"\")").unwrap(); + assert_eq!(result, ""); + } + + #[test] + fn test_last_keyword_multiple_spaces() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"hello world \")").unwrap(); + assert_eq!(result, "world"); + } + + #[test] + fn test_last_keyword_tabs_and_newlines() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"hello\tworld\n\")").unwrap(); + assert_eq!(result, "world"); + } + + #[test] + fn test_last_keyword_with_variable() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + let mut scope = Scope::new(); + + scope.push("text", "this is a test"); + let result: String = engine.eval_with_scope(&mut scope, "LAST(text)").unwrap(); + + assert_eq!(result, "test"); + } + + #[test] + fn test_last_keyword_whitespace_only() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\" \")").unwrap(); + assert_eq!(result, ""); + } + + #[test] + fn test_last_keyword_mixed_whitespace() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"hello\t \n world \t final\")").unwrap(); + assert_eq!(result, "final"); + } + + #[test] + fn test_last_keyword_expression() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // Test with string concatenation + let result: String = engine.eval("LAST(\"hello\" + \" \" + \"world\")").unwrap(); + assert_eq!(result, "world"); + } + + #[test] + fn test_last_keyword_unicode() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let result: String = engine.eval("LAST(\"hello 世界 мир world\")").unwrap(); + assert_eq!(result, "world"); + } + + #[test] + fn test_last_keyword_in_expression() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // Test using the result in another expression + let result: bool = engine.eval("LAST(\"hello world\") == \"world\"").unwrap(); + assert!(result); + } + + #[test] + fn test_last_keyword_complex_scenario() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + let mut scope = Scope::new(); + + scope.push("sentence", "The quick brown fox jumps over the lazy dog"); + let result: String = engine.eval_with_scope(&mut scope, "LAST(sentence)").unwrap(); + + assert_eq!(result, "dog"); + } + + #[test] + #[should_panic] // This should fail because the syntax expects parentheses + fn test_last_keyword_missing_parentheses() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // This should fail - missing parentheses + let _: String = engine.eval("LAST \"hello world\"").unwrap(); + } + + #[test] + #[should_panic] // This should fail because of incomplete syntax + fn test_last_keyword_missing_closing_parenthesis() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // This should fail - missing closing parenthesis + let _: String = engine.eval("LAST(\"hello world\"").unwrap(); + } + + #[test] + #[should_panic] // This should fail because of incomplete syntax + fn test_last_keyword_missing_opening_parenthesis() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // This should fail - missing opening parenthesis + let _: String = engine.eval("LAST \"hello world\")").unwrap(); + } + + #[test] + fn test_last_keyword_dynamic_type() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // Test that the function returns the correct Dynamic type + let result = engine.eval::("LAST(\"test string\")").unwrap(); + assert!(result.is::()); + assert_eq!(result.to_string(), "string"); + } + + #[test] + fn test_last_keyword_nested_expression() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // Test with a more complex nested expression + let result: String = engine.eval("LAST(\"The result is: \" + \"hello world\")").unwrap(); + assert_eq!(result, "world"); + } +} + +#[cfg(test)] +mod integration_tests { + use super::*; + + #[test] + fn test_last_keyword_in_script() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let script = r#" + let sentence1 = "first second third"; + let sentence2 = "alpha beta gamma"; + + let last1 = LAST(sentence1); + let last2 = LAST(sentence2); + + last1 + " and " + last2 + "#; + + let result: String = engine.eval(script).unwrap(); + assert_eq!(result, "third and gamma"); + } + + #[test] + fn test_last_keyword_with_function() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + // Register a function that returns a string + engine.register_fn("get_name", || -> String { "john doe".to_string() }); + + let result: String = engine.eval("LAST(get_name())").unwrap(); + assert_eq!(result, "doe"); + } + + #[test] + fn test_last_keyword_multiple_calls() { + let mut engine = Engine::new(); + last_keyword(&mut engine); + + let script = r#" + let text1 = "apple banana cherry"; + let text2 = "cat dog elephant"; + + let result1 = LAST(text1); + let result2 = LAST(text2); + + result1 + "-" + result2 + "#; + + let result: String = engine.eval(script).unwrap(); + assert_eq!(result, "cherry-elephant"); + } +} \ No newline at end of file