petcarescript
Version:
PetCareScript - A modern, expressive programming language designed for humans
1,742 lines (1,442 loc) • 124 kB
Markdown
<div align="center">
<img src="https://raw.githubusercontent.com/estevam5s/estevam5s/33fea64736a9adcf7503be73194a1955a021a793/Images/icone.svg" alt="PetCareScript Logo" width="200" height="200" style="border-radius: 50%; box-shadow: 0 10px 30px rgba(46, 125, 50, 0.3);">
# 🐾 PetCareScript - Documentação Completa
> Uma linguagem de programação moderna, expressiva e amigável para humanos com suporte completo a async, HTTP, banco de dados e testes
[](https://www.npmjs.com/package/petcarescript)
[](https://github.com/PetCareAi/petcarescript/blob/main/LICENSE)
[](https://www.npmjs.com/package/petcarescript)
[](https://nodejs.org/)
[](https://github.com/PetCareAi/petcarescript)
[](https://github.com/PetCareAi/petcarescript/pulls)
[](https://github.com/PetCareAi/petcarescript/stargazers)
[](https://marketplace.visualstudio.com/items?itemName=petcarescript.petcarescript)
[](https://language.petcareai.com.br/)
**[🌐 Site Oficial](https://language.petcareai.com.br/) • [📖 Documentação](https://language.petcareai.com.br/docs) • [🧩 Extensão VS Code](https://marketplace.visualstudio.com/items?itemName=petcarescript.petcarescript) • [💬 Comunidade](https://discord.gg/petcarescript) • [🎓 Tutoriais](https://language.petcareai.com.br/tutorials)**
</div>
---
## 🌟 **Por que PetCareScript?**
PetCareScript é uma linguagem de programação revolucionária que combina **simplicidade**, **poder** e **elegância**. Desenvolvida pela **PetCareAI**, ela oferece uma sintaxe naturalmente legível que torna a programação mais humana e acessível.
### ✨ **Características Principais**
🎯 **Sintaxe Natural** - Escreva código que qualquer pessoa pode entender
⚡ **Performance** - Interpretador otimizado com execução rápida
🔧 **Ferramentas Integradas** - HTTP, banco de dados, testes e muito mais
🌐 **Async/Await** - Programação assíncrona moderna e intuitiva
🏗️ **OOP Avançado** - Sistema de blueprints poderoso e flexível
🧪 **TDD/BDD** - Framework de testes completo integrado
📦 **Módulos** - Sistema de importação/exportação robusto
🎨 **Extensibilidade** - Fácil integração com bibliotecas externas
---
## 📖 **Índice**
<details>
<summary>📚 <strong>Navegação Completa</strong></summary>
1. [🚀 Instalação](#-instalação)
2. [⚡ Início Rápido](#-início-rápido)
3. [🎯 Primeiros Passos](#-primeiros-passos)
4. [📝 Sintaxe Básica](#-sintaxe-básica)
5. [🔤 Palavras Reservadas](#-palavras-reservadas)
6. [🏗️ Programação Orientada a Objetos](#️-programação-orientada-a-objetos)
7. [⚡ Programação Assíncrona](#-programação-assíncrona)
8. [🌐 Servidor HTTP e APIs](#-servidor-http-e-apis)
9. [🗄️ Banco de Dados](#️-banco-de-dados)
10. [🧪 Framework de Testes](#-framework-de-testes)
11. [📦 Sistema de Módulos](#-sistema-de-módulos)
12. [🔧 Operadores Avançados](#-operadores-avançados)
13. [📚 Biblioteca Padrão](#-biblioteca-padrão)
14. [🛠️ Ferramentas e Extensões](#️-ferramentas-e-extensões)
15. [📁 Extensão de Arquivo](#-extensão-de-arquivo)
16. [🎓 Tutoriais Avançados](#-tutoriais-avançados)
17. [📋 Changelog](#-changelog)
18. [🤝 Contribuição](#-contribuição)
19. [📄 Licença](#-licença)
</details>
---
## 🚀 **Instalação**
### 📦 **Instalação Global (Recomendada)**
```bash
# Via NPM
npm install -g petcarescript
# Via Yarn
yarn global add petcarescript
# Verificar instalação
pcs --version
```
### 🏠 **Instalação Local**
```bash
# Para projeto específico
npm install petcarescript
npx pcs meuarquivo.pcs
```
### 💾 **Instalação via Executáveis**
```bash
# Linux/macOS - Instalação automática
curl -sSL https://raw.githubusercontent.com/PetCareAi/petcarescript/main/install.sh | bash
# Windows - PowerShell como Administrador
irm https://raw.githubusercontent.com/PetCareAi/petcarescript/main/install.ps1 | iex
```
### 🧩 **Extensão VS Code**
Instale a extensão oficial para VS Code:
[](https://marketplace.visualstudio.com/items?itemName=petcarescript.petcarescript)
**Recursos da Extensão:**
- 🎨 Syntax highlighting
- 🔍 IntelliSense e autocompletar
- 🐛 Debugging integrado
- 📋 Snippets de código
- 🔧 Linting e formatação
- 🏃 Execução direta no editor
---
## ⚡ **Início Rápido**
### 🌟 **Seu Primeiro Programa**
```javascript
// hello.pcs
show "🐾 Bem-vindo ao PetCareScript!";
store name = "Desenvolvedor";
show "Olá, " + name + "! Vamos programar?";
build greet(person) {
give "🎉 Oi, " + person + "! Que bom ter você aqui!";
}
store message = greet(name);
show message;
```
**Execute:**
```bash
pcs hello.pcs
```
### 🔥 **REPL Interativo**
```bash
# Iniciar REPL
pcs
# Teste comandos interativamente
pcs> store x = 42;
pcs> show x * 2;
pcs> build square(n) { give n * n; }
pcs> show square(8);
pcs> exit
```
---
## 🎯 **Primeiros Passos**
### 1️⃣ **Variáveis e Tipos**
```javascript
// Tipos básicos
store name = "Ana Silva"; // String
store age = 28; // Number
store isActive = yes; // Boolean (true)
store isInactive = no; // Boolean (false)
store nothing = empty; // Null
store items = [1, 2, 3, 4]; // Array
store person = {
name: "João",
age: 35,
skills: ["JavaScript", "PetCareScript"]
}; // Object
```
### 2️⃣ **Funções Básicas**
```javascript
// Função simples
build sayHello(name) {
show "Olá, " + name + "!";
}
// Função com retorno
build multiply(a, b) {
give a * b; // 'give' é como 'return'
}
// Função com múltiplos parâmetros
build createUser(name, age, email, role = "user") {
give {
name: name,
age: age,
email: email,
role: role,
createdAt: now(),
active: yes
};
}
// Usando funções
sayHello("Maria");
store result = multiply(7, 8);
store newUser = createUser("Pedro", 25, "pedro@email.com", "admin");
show newUser;
```
### 3️⃣ **Condicionais Inteligentes**
```javascript
store score = 87;
// Condicional básica
when (score >= 90) {
show "Excelente! Nota A";
} otherwise when (score >= 80) {
show "Muito bom! Nota B";
} otherwise when (score >= 70) {
show "Bom! Nota C";
} otherwise {
show "Precisa melhorar";
}
// Unless (oposto de if)
unless (score < 60) {
show "Aprovado!";
}
// Operadores amigáveis
when (score between 80 and 90) {
show "Nota na faixa B+";
}
store grades = [85, 92, 78];
when (grades contains 92) {
show "Tem nota excelente!";
}
```
---
## 📝 **Sintaxe Básica**
### 🔢 **Operadores**
```javascript
// Aritméticos
store sum = 15 + 10; // 25
store diff = 20 - 8; // 12
store product = 6 * 7; // 42
store quotient = 84 / 7; // 12
store remainder = 17 % 5; // 2
// Comparação amigável
store isEqual = (10 is 10); // yes (true)
store isDifferent = (10 isnt 5); // yes (true)
store isGreater = (15 > 10); // yes (true)
store isInRange = (50 between 30 and 70); // yes (true)
// Lógicos naturais
store both = (yes also yes); // yes (true)
store either = (yes either no); // yes (true)
store neither = (not yes); // no (false)
store combined = (age >= 18 and hasLicense);
```
### 🔄 **Loops Avançados**
```javascript
// For loop tradicional
loop (store i = 0; i < 5; i = i + 1) {
show "Contador: " + i;
}
// While loop
store count = 0;
repeat (count < 3) {
show "Repetição: " + count;
count = count + 1;
}
// Until loop (oposto de while)
store countdown = 5;
until (countdown is 0) {
show "Contagem regressiva: " + countdown;
countdown = countdown - 1;
}
// ForEach para arrays
store languages = ["JavaScript", "Python", "PetCareScript"];
foreach (lang in languages) {
show "Linguagem: " + lang;
}
// ForEach para objetos
store user = { name: "Ana", age: 30, city: "SP" };
foreach (key in Object.keys(user)) {
show key + ": " + user[key];
}
// Controle de loop
loop (store j = 0; j < 10; j = j + 1) {
when (j is 3) {
continue; // Pula para próxima iteração
}
when (j is 7) {
break; // Sai do loop
}
show j;
}
```
### 🎛️ **Switch Statement**
```javascript
store dayOfWeek = "monday";
switch (dayOfWeek) {
case "monday":
show "Segunda-feira: Novo começo!";
break;
case "tuesday":
show "Terça-feira: Produtividade!";
break;
case "wednesday":
show "Quarta-feira: Meio da semana!";
break;
case "friday":
show "Sexta-feira: Quase fim de semana!";
break;
default:
show "Dia desconhecido";
}
```
---
## 🔤 Palavras Reservadas
### Core Language (Essenciais)
| Palavra | Equivalente | Descrição |
|---------|-------------|-----------|
| `store` | `let/var` | Declarar variável |
| `when` | `if` | Condicional |
| `otherwise` | `else` | Alternativa |
| `repeat` | `while` | Loop while |
| `loop` | `for` | Loop for |
| `again` | `while` | Outro while |
| `build` | `function` | Declarar função |
| `give` | `return` | Retornar valor |
| `yes` | `true` | Booleano verdadeiro |
| `no` | `false` | Booleano falso |
| `empty` | `null` | Valor nulo |
| `show` | `console.log` | Exibir saída |
| `blueprint` | `class` | Declarar classe |
| `self` | `this` | Referência ao objeto |
| `parent` | `super` | Referência à classe pai |
### Operadores Lógicos
| Palavra | Equivalente | Descrição |
|---------|-------------|-----------|
| `also` | `&&` | AND lógico |
| `either` | `\|\|` | OR lógico |
| `not` | `!` | NOT lógico |
| `and` | `&&` | Alias para AND |
| `or` | `\|\|` | Alias para OR |
### Operadores de Comparação
| Palavra | Equivalente | Descrição |
|---------|-------------|-----------|
| `is` | `==` | Igualdade |
| `isnt` | `!=` | Diferença |
| `contains` | `.includes()` | Contém elemento |
| `in` | `in` | Elemento em coleção |
| `of` | `of` | Para iteração |
| `like` | Pattern match | Similaridade |
| `between` | Range check | Entre valores |
| `matches` | Regex match | Pattern matching |
### Controle de Fluxo
| Palavra | Descrição |
|---------|-----------|
| `break` | Sair do loop |
| `continue` | Próxima iteração |
| `unless` | If negativo |
| `until` | While negativo |
| `foreach` | Loop por elementos |
| `switch` | Switch statement |
| `case` | Caso do switch |
| `default` | Caso padrão |
### Tratamento de Erros
| Palavra | Equivalente | Descrição |
|---------|-------------|-----------|
| `attempt` | `try` | Tentar execução |
| `catch` | `catch` | Capturar erro |
| `finally` | `finally` | Sempre executar |
| `throw` | `throw` | Lançar erro |
### Programação Assíncrona
| Palavra | Descrição |
|---------|-----------|
| `async` | Função assíncrona |
| `await` | Esperar promessa |
| `promise` | Promessa |
| `then` | Callback de sucesso |
| `resolve` | Resolver promessa |
| `reject` | Rejeitar promessa |
| `timeout` | Função de timeout |
| `interval` | Função de intervalo |
### HTTP e APIs
| Palavra | Descrição |
|---------|-----------|
| `http` | Módulo HTTP |
| `get` | HTTP GET |
| `post` | HTTP POST |
| `put` | HTTP PUT |
| `delete` | HTTP DELETE |
| `patch` | HTTP PATCH |
| `server` | Servidor HTTP |
| `route` | Rota da API |
| `middleware` | Middleware |
| `cors` | CORS middleware |
| `json` | Tipo/parser JSON |
### Testing
| Palavra | Descrição |
|---------|-----------|
| `test` | Teste individual |
| `describe` | Suíte de testes |
| `it` | Caso de teste |
| `expect` | Asserção |
| `assert` | Asserção simples |
| `mock` | Mock de função |
| `spy` | Spy de função |
| `before` | Hook antes |
| `after` | Hook depois |
| `beforeEach` | Hook antes de cada |
| `afterEach` | Hook depois de cada |
### Módulos
| Palavra | Descrição |
|---------|-----------|
| `import` | Importar módulo |
| `export` | Exportar módulo |
| `use` | Usar módulo |
| `from` | De módulo |
| `module` | Declarar módulo |
| `namespace` | Namespace |
| `as` | Alias |
| `require` | Requerer módulo |
### Database
| Palavra | Descrição |
|---------|-----------|
| `database` | Banco de dados |
| `connect` | Conectar |
| `query` | Consulta |
| `select` | SELECT SQL |
| `insert` | INSERT SQL |
| `update` | UPDATE SQL |
| `delete` | DELETE SQL |
| `where` | WHERE SQL |
| `join` | JOIN SQL |
| `table` | Tabela |
| `transaction` | Transação |
| `commit` | Confirmar |
| `rollback` | Reverter |
### Tipos de Dados
| Palavra | Descrição |
|---------|-----------|
| `array` | Array/lista |
| `object` | Objeto |
| `map` | Mapa/dicionário |
| `set` | Conjunto |
| `enum` | Enumeração |
| `interface` | Interface |
| `type` | Tipo personalizado |
### Features Avançadas
| Palavra | Descrição |
|---------|-----------|
| `yield` | Yield para generators |
| `generator` | Função generator |
| `decorator` | Decorator |
| `lazy` | Avaliação lazy |
| `memoize` | Memoização |
---
## 🏗️ **Programação Orientada a Objetos**
### 🏛️ **Blueprints (Classes)**
```javascript
// Blueprint básico
blueprint Animal {
build init(name, species) {
self.name = name;
self.species = species;
self.energy = 100;
self.happiness = 50;
}
build eat(food) {
self.energy = self.energy + 15;
show self.name + " comeu " + food + " e ganhou energia!";
give self.energy;
}
build play() {
when (self.energy > 20) {
self.energy = self.energy - 10;
self.happiness = self.happiness + 20;
show self.name + " está brincando! 🎾";
} otherwise {
show self.name + " está muito cansado para brincar...";
}
}
build status() {
give {
name: self.name,
species: self.species,
energy: self.energy,
happiness: self.happiness,
mood: self.happiness > 70 ? "feliz" : "normal"
};
}
}
// Herança
blueprint Dog extends Animal {
build init(name, breed) {
parent.init(name, "Cachorro");
self.breed = breed;
self.tricks = [];
}
build bark() {
show self.name + " faz: AU AU! 🐕";
give "woof";
}
build learnTrick(trick) {
push(self.tricks, trick);
self.happiness = self.happiness + 10;
show self.name + " aprendeu: " + trick + "! 🎉";
}
build performTrick() {
when (size(self.tricks) > 0) {
store trick = randomChoice(self.tricks);
show self.name + " fez: " + trick + "! 👏";
self.happiness = self.happiness + 5;
} otherwise {
show self.name + " ainda não sabe truques...";
}
}
}
// Uso prático
store myDog = Dog("Rex", "Golden Retriever");
myDog.eat("ração premium");
myDog.learnTrick("sentar");
myDog.learnTrick("dar a patinha");
myDog.bark();
myDog.performTrick();
myDog.play();
store dogStatus = myDog.status();
show "Status do " + dogStatus.name + ": " + stringifyJSON(dogStatus);
```
### 🎭 **Interfaces e Enums**
```javascript
// Interface
interface Flyable {
fly(): void;
altitude: number;
maxSpeed: number;
}
// Enumeração
enum OrderStatus {
PENDING,
PROCESSING,
SHIPPED,
DELIVERED,
CANCELLED
}
// Blueprint implementando interface
blueprint Bird extends Animal implements Flyable {
build init(name, wingSpan) {
parent.init(name, "Pássaro");
self.wingSpan = wingSpan;
self.altitude = 0;
self.maxSpeed = 50;
}
build fly() {
self.altitude = 100;
show self.name + " está voando! ✈️";
}
}
// Uso de enum
store orderStatus = OrderStatus.PROCESSING;
when (orderStatus is OrderStatus.DELIVERED) {
show "Pedido entregue!";
}
```
---
## ⚡ **Programação Assíncrona**
### 🔄 **Async/Await**
```javascript
// Função assíncrona básica
async build fetchUserData(userId) {
show "🔍 Buscando dados do usuário " + userId + "...";
attempt {
store response = await get("https://api.example.com/users/" + userId);
store userData = parseJSON(response.data);
show "✅ Usuário encontrado: " + userData.name;
give userData;
} catch (error) {
show "❌ Erro ao buscar usuário: " + error;
give empty;
}
}
// Múltiplas operações assíncronas
async build processUserOrder(userId, orderId) {
show "📦 Processando pedido " + orderId + "...";
// Buscar dados em paralelo
store [user, order, inventory] = await all([
fetchUserData(userId),
fetchOrderData(orderId),
checkInventory(orderId)
]);
when (user and order and inventory.available) {
store result = await processPayment(user, order);
when (result.success) {
await sendConfirmationEmail(user.email, order);
show "🎉 Pedido processado com sucesso!";
give { success: yes, orderId: orderId };
}
} otherwise {
show "❌ Não foi possível processar o pedido";
give { success: no, error: "Dados incompletos" };
}
}
// Usando a função
async build main() {
store result = await processUserOrder(123, "ORD-456");
show "Resultado: " + stringifyJSON(result);
}
main();
```
### 🎯 **Promises Avançadas**
```javascript
// Criando promises personalizadas
build createDownloadPromise(url, filename) {
give Promise(build(resolve, reject) {
show "📥 Iniciando download de " + filename + "...";
timeout(build() {
store success = randomInt(1, 10) > 3; // 70% chance de sucesso
when (success) {
show "✅ Download concluído: " + filename;
resolve({
filename: filename,
size: randomInt(100, 1000) + "KB",
url: url
});
} otherwise {
show "❌ Falha no download: " + filename;
reject("Network error: " + filename);
}
}, randomInt(1000, 3000)); // 1-3 segundos
});
}
// Operações paralelas com controle
async build batchDownload() {
store urls = [
"https://api.example.com/file1.pdf",
"https://api.example.com/file2.jpg",
"https://api.example.com/file3.zip"
];
store downloadPromises = [];
foreach (url in urls) {
store filename = split(url, "/").pop();
push(downloadPromises, createDownloadPromise(url, filename));
}
show "🚀 Iniciando downloads em paralelo...";
attempt {
store results = await all(downloadPromises);
show "🎉 Todos os downloads concluídos!";
foreach (result in results) {
show "📁 " + result.filename + " (" + result.size + ")";
}
give results;
} catch (error) {
show "⚠️ Alguns downloads falharam: " + error;
// Tentar downloads individuais para ver quais falharam
foreach (promise in downloadPromises) {
promise
.then(build(result) {
show "✅ Recuperado: " + result.filename;
})
.catch(build(error) {
show "❌ Falhou definitivamente: " + error;
});
}
}
}
batchDownload();
```
---
## 🌐 **Servidor HTTP e APIs**
### 🚀 **API REST Completa**
```javascript
// server.pcs - Servidor HTTP profissional
import { createServer, cors, json, logger } from "http";
import { connect, types } from "database";
async build startServer() {
// Configuração do banco de dados
store db = connect("petcare_api.db");
await db.connect();
// Criar tabelas
await db.createTable("users", {
id: types.PRIMARY_KEY,
name: types.TEXT + " NOT NULL",
email: types.TEXT + " UNIQUE NOT NULL",
password: types.TEXT + " NOT NULL",
role: types.TEXT + " DEFAULT 'user'",
avatar: types.TEXT,
created_at: types.TIMESTAMP,
updated_at: types.TIMESTAMP
});
await db.createTable("posts", {
id: types.PRIMARY_KEY,
user_id: types.INTEGER + " NOT NULL",
title: types.TEXT + " NOT NULL",
content: types.TEXT,
published: types.BOOLEAN + " DEFAULT 0",
tags: types.JSON,
created_at: types.TIMESTAMP,
updated_at: types.TIMESTAMP
});
// Configuração do servidor
store server = createServer(3000);
// Middleware globais
server.use(cors({
origin: ["http://localhost:3000", "https://petcareai.com.br"],
credentials: yes
}));
server.use(json({ limit: "10mb" }));
server.use(logger("combined"));
// Middleware de autenticação
build authMiddleware(req, res, next) {
store token = req.headers.authorization;
when (token and startsWith(token, "Bearer ")) {
store actualToken = slice(token, 7); // Remove "Bearer "
// Validação simples do token (em produção, use JWT)
when (actualToken is "valid-api-key-123") {
req.user = { id: 1, name: "Admin", role: "admin" };
next();
} otherwise {
res.status(401).json({
error: "Token inválido",
code: "INVALID_TOKEN"
});
}
} otherwise {
res.status(401).json({
error: "Token necessário",
code: "MISSING_TOKEN"
});
}
}
// Rotas públicas
server.get("/health", build(req, res) {
res.json({
status: "healthy",
timestamp: now(),
version: "1.2.3",
uptime: process.uptime()
});
});
// API de usuários
server.get("/api/users", authMiddleware, build(req, res) {
attempt {
store page = toNumber(req.query.page) or 1;
store limit = toNumber(req.query.limit) or 10;
store offset = (page - 1) * limit;
store users = await db.select("users", {}, {
limit: limit,
offset: offset,
orderBy: "created_at",
order: "DESC"
});
// Remover senhas do resultado
store safeUsers = map(users, build(user) {
store { password, ...safeUser } = user;
give safeUser;
});
res.json({
data: safeUsers,
pagination: {
page: page,
limit: limit,
total: size(users)
}
});
} catch (error) {
res.status(500).json({
error: "Erro interno do servidor",
details: error.message
});
}
});
server.post("/api/users", build(req, res) {
attempt {
store { name, email, password, role } = req.body;
// Validação
when (not name or not email or not password) {
res.status(400).json({
error: "Campos obrigatórios: name, email, password"
});
give;
}
when (not isEmail(email)) {
res.status(400).json({
error: "Email inválido"
});
give;
}
// Verificar se email já existe
store existingUser = await db.select("users", { email: email });
when (size(existingUser) > 0) {
res.status(409).json({
error: "Email já cadastrado"
});
give;
}
// Criar usuário
store hashedPassword = hashPassword(password); // Implementar hash
store newUser = await db.insert("users", {
name: name,
email: email,
password: hashedPassword,
role: role or "user"
});
// Buscar usuário criado (sem senha)
store createdUser = await db.select("users", { id: newUser.lastID });
store { password: _, ...safeUser } = createdUser[0];
res.status(201).json({
message: "Usuário criado com sucesso",
data: safeUser
});
} catch (error) {
res.status(500).json({
error: "Erro ao criar usuário",
details: error.message
});
}
});
// API de posts
server.get("/api/posts", build(req, res) {
attempt {
store posts = await db.query(`
SELECT p.*, u.name as author_name, u.email as author_email
FROM posts p
JOIN users u ON p.user_id = u.id
WHERE p.published = 1
ORDER BY p.created_at DESC
`);
res.json({
data: posts,
count: size(posts)
});
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// Rota para upload de arquivo
server.post("/api/upload", authMiddleware, build(req, res) {
// Simulação de upload
store filename = "uploaded_" + timestamp() + ".jpg";
res.json({
message: "Arquivo enviado com sucesso",
filename: filename,
url: "/uploads/" + filename
});
});
// Tratamento de erro global
server.use(build(error, req, res, next) {
show "❌ Erro não tratado: " + error.message;
res.status(500).json({
error: "Erro interno do servidor",
requestId: generateId()
});
});
// Iniciar servidor
server.listen(build() {
show "🚀 Servidor PetCareScript rodando em http://localhost:3000";
show "📋 Rotas disponíveis:";
show " GET /health - Status do servidor";
show " GET /api/users - Listar usuários";
show " POST /api/users - Criar usuário";
show " GET /api/posts - Listar posts";
show " POST /api/upload - Upload de arquivo";
show "🔐 Use o header: Authorization: Bearer valid-api-key-123";
});
}
// Funções auxiliares
build hashPassword(password) {
// Em produção, use bcrypt ou similar
give "hashed_" + password;
}
build generateId() {
give "req_" + timestamp() + "_" + randomInt(1000, 9999);
}
build isEmail(email) {
store emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
give emailRegex.test(email);
}
// Inicializar servidor
startServer();
```
---
## 🗄️ **Banco de Dados**
### 💾 **Operações Avançadas**
```javascript
// database-advanced.pcs
import { connect, types, createMigration, createSeed } from "database";
async build setupDatabase() {
store db = connect("petcare_complete.db");
await db.connect();
// Migração completa
store migrations = [
createMigration("001_create_users_table", async build(db) {
await db.createTable("users", {
id: types.PRIMARY_KEY,
username: types.TEXT + " UNIQUE NOT NULL",
email: types.TEXT + " UNIQUE NOT NULL",
password_hash: types.TEXT + " NOT NULL",
first_name: types.TEXT,
last_name: types.TEXT,
avatar_url: types.TEXT,
bio: types.TEXT,
is_active: types.BOOLEAN + " DEFAULT 1",
email_verified: types.BOOLEAN + " DEFAULT 0",
created_at: types.TIMESTAMP,
updated_at: types.TIMESTAMP
});
// Índices
await db.run("CREATE INDEX idx_users_email ON users(email)");
await db.run("CREATE INDEX idx_users_username ON users(username)");
}),
createMigration("002_create_posts_table", async build(db) {
await db.createTable("posts", {
id: types.PRIMARY_KEY,
user_id: types.INTEGER + " NOT NULL",
title: types.TEXT + " NOT NULL",
slug: types.TEXT + " UNIQUE NOT NULL",
content: types.TEXT,
excerpt: types.TEXT,
featured_image: types.TEXT,
status: types.TEXT + " DEFAULT 'draft'",
published_at: types.TIMESTAMP,
created_at: types.TIMESTAMP,
updated_at: types.TIMESTAMP,
views_count: types.INTEGER + " DEFAULT 0",
likes_count: types.INTEGER + " DEFAULT 0"
});
await db.run("CREATE INDEX idx_posts_user_id ON posts(user_id)");
await db.run("CREATE INDEX idx_posts_status ON posts(status)");
await db.run("CREATE INDEX idx_posts_published_at ON posts(published_at)");
}),
createMigration("003_create_categories_and_tags", async build(db) {
await db.createTable("categories", {
id: types.PRIMARY_KEY,
name: types.TEXT + " UNIQUE NOT NULL",
slug: types.TEXT + " UNIQUE NOT NULL",
description: types.TEXT,
color: types.TEXT + " DEFAULT '#007ACC'",
created_at: types.TIMESTAMP
});
await db.createTable("tags", {
id: types.PRIMARY_KEY,
name: types.TEXT + " UNIQUE NOT NULL",
slug: types.TEXT + " UNIQUE NOT NULL",
created_at: types.TIMESTAMP
});
await db.createTable("post_categories", {
post_id: types.INTEGER + " NOT NULL",
category_id: types.INTEGER + " NOT NULL",
created_at: types.TIMESTAMP
});
await db.createTable("post_tags", {
post_id: types.INTEGER + " NOT NULL",
tag_id: types.INTEGER + " NOT NULL",
created_at: types.TIMESTAMP
});
})
];
await db.migrate(migrations);
// Seeds com dados realistas
store seeds = [
createSeed("users_seed", async build(db) {
store users = [
{
username: "admin",
email: "admin@petcareai.com.br",
password_hash: "hashed_admin_password",
first_name: "Admin",
last_name: "Sistema",
bio: "Administrador do sistema",
is_active: 1,
email_verified: 1
},
{
username: "joao_dev",
email: "joao@exemplo.com",
password_hash: "hashed_joao_password",
first_name: "João",
last_name: "Silva",
bio: "Desenvolvedor apaixonado por PetCareScript",
is_active: 1,
email_verified: 1
},
{
username: "maria_tech",
email: "maria@exemplo.com",
password_hash: "hashed_maria_password",
first_name: "Maria",
last_name: "Santos",
bio: "Tech lead especialista em APIs",
is_active: 1,
email_verified: 1
}
];
foreach (userData in users) {
await db.insert("users", userData);
}
}),
createSeed("categories_seed", async build(db) {
store categories = [
{ name: "Tecnologia", slug: "tecnologia", description: "Posts sobre tecnologia", color: "#007ACC" },
{ name: "PetCareScript", slug: "petcarescript", description: "Tutoriais da linguagem", color: "#2E7D32" },
{ name: "Web Development", slug: "web-dev", description: "Desenvolvimento web", color: "#FF6B6B" },
{ name: "API Design", slug: "api-design", description: "Design de APIs", color: "#4ECDC4" }
];
foreach (category in categories) {
await db.insert("categories", category);
}
}),
createSeed("posts_seed", async build(db) {
store posts = [
{
user_id: 1,
title: "Introdução ao PetCareScript",
slug: "introducao-petcarescript",
content: "PetCareScript é uma linguagem revolucionária...",
excerpt: "Aprenda os conceitos básicos",
status: "published",
published_at: now(),
views_count: 150,
likes_count: 23
},
{
user_id: 2,
title: "APIs RESTful com PetCareScript",
slug: "apis-restful-petcarescript",
content: "Como criar APIs modernas e eficientes...",
excerpt: "Tutorial completo de APIs",
status: "published",
published_at: now(),
views_count: 89,
likes_count: 15
}
];
foreach (post in posts) {
await db.insert("posts", post);
}
})
];
await db.seed(seeds);
give db;
}
// Query Builder avançado
async build demonstrateQueries() {
store db = await setupDatabase();
// Query complexa com JOIN
store postsWithAuthors = await db.query(`
SELECT
p.id,
p.title,
p.excerpt,
p.status,
p.published_at,
p.views_count,
p.likes_count,
u.username,
u.first_name,
u.last_name,
u.avatar_url
FROM posts p
JOIN users u ON p.user_id = u.id
WHERE p.status = 'published'
ORDER BY p.published_at DESC
LIMIT 10
`);
show "📝 Posts com autores:";
foreach (post in postsWithAuthors) {
show " " + post.title + " por " + post.first_name + " " + post.last_name;
}
// Usar Query Builder
store popularPosts = await query("posts")
.select(["title", "views_count", "likes_count"])
.where("status", "published")
.where("views_count", ">=", 100)
.orderBy("views_count", "DESC")
.limit(5)
.execute(db);
show "🔥 Posts populares:";
foreach (post in popularPosts) {
show " " + post.title + " (" + post.views_count + " views)";
}
// Transação complexa
await db.transaction(async build(db) {
// Criar novo usuário
store newUser = await db.insert("users", {
username: "teste_user",
email: "teste@exemplo.com",
password_hash: "hashed_password",
first_name: "Teste",
last_name: "Usuário"
});
// Criar post para este usuário
store newPost = await db.insert("posts", {
user_id: newUser.lastID,
title: "Meu primeiro post",
slug: "meu-primeiro-post",
content: "Este é meu primeiro post no sistema!",
status: "published",
published_at: now()
});
// Criar categoria se não existe
store category = await db.select("categories", { slug: "primeiro-post" });
when (size(category) is 0) {
await db.insert("categories", {
name: "Primeiros Posts",
slug: "primeiro-post",
description: "Posts de novos usuários"
});
}
show "✅ Usuário e post criados com sucesso em transação!";
});
await db.close();
}
demonstrateQueries();
```
---
## 🧪 **Framework de Testes**
### 🎯 **TDD/BDD Completo**
```javascript
// tests/complete-test-suite.pcs
import { describe, it, expect, before, after, beforeEach, afterEach, mock, spy } from "testing";
// Test Suite para Calculator
describe("Calculator Advanced Tests", build() {
store calculator;
store mockLogger;
before(build() {
show "🔧 Configurando ambiente de teste...";
mockLogger = mock();
mockLogger.mockImplementation(build(message) {
show "LOG: " + message;
});
});
beforeEach(build() {
calculator = Calculator(mockLogger);
});
afterEach(build() {
mockLogger.clear();
});
after(build() {
show "🧹 Limpando ambiente de teste...";
});
describe("Basic Operations", build() {
it("should add positive numbers correctly", build() {
store result = calculator.add(2, 3);
expect(result).toBe(5);
expect(mockLogger.toHaveBeenCalledWith("Adding 2 + 3")).toBe(yes);
});
it("should handle negative numbers", build() {
store result = calculator.add(-5, 3);
expect(result).toBe(-2);
});
it("should multiply numbers", build() {
store result = calculator.multiply(4, 5);
expect(result).toEqual(20);
});
it("should handle division by zero", build() {
expect(build() {
calculator.divide(10, 0);
}).toThrow("Division by zero");
});
});
describe("Advanced Operations", build() {
it("should calculate percentage", build() {
store result = calculator.percentage(50, 200);
expect(result).toBe(25);
});
it("should calculate square root", build() {
store result = calculator.sqrt(16);
expect(result).toBe(4);
});
it("should handle negative square root", build() {
expect(build() {
calculator.sqrt(-1);
}).toThrow("Cannot calculate square root of negative number");
});
});
describe("Memory Operations", build() {
it("should store and recall memory", build() {
calculator.memoryStore(42);
store result = calculator.memoryRecall();
expect(result).toBe(42);
});
it("should clear memory", build() {
calculator.memoryStore(42);
calculator.memoryClear();
store result = calculator.memoryRecall();
expect(result).toBe(0);
});
});
});
// Blueprint Calculator para testes
blueprint Calculator {
build init(logger = empty) {
self.logger = logger;
self.memory = 0;
self.history = [];
}
build add(a, b) {
when (self.logger) {
self.logger.fn("Adding " + a + " + " + b);
}
store result = a + b;
push(self.history, { operation: "add", a: a, b: b, result: result });
give result;
}
build multiply(a, b) {
when (self.logger) {
self.logger.fn("Multiplying " + a + " * " + b);
}
store result = a * b;
push(self.history, { operation: "multiply", a: a, b: b, result: result });
give result;
}
build divide(a, b) {
when (b is 0) {
throw "Division by zero";
}
when (self.logger) {
self.logger.fn("Dividing " + a + " / " + b);
}
store result = a / b;
push(self.history, { operation: "divide", a: a, b: b, result: result });
give result;
}
build percentage(part, total) {
give (part / total) * 100;
}
build sqrt(n) {
when (n < 0) {
throw "Cannot calculate square root of negative number";
}
give Math.sqrt(n);
}
build memoryStore(value) {
self.memory = value;
}
build memoryRecall() {
give self.memory;
}
build memoryClear() {
self.memory = 0;
}
build getHistory() {
give self.history;
}
}
// Test Suite para API
describe("API Endpoint Tests", build() {
store server;
store apiClient;
before(async build() {
server = await startTestServer();
apiClient = createApiClient("http://localhost:3001");
});
after(async build() {
await server.close();
});
describe("User Management", build() {
it("should create a new user", async build() {
store userData = {
name: "Test User",
email: "test@example.com",
password: "securepassword123"
};
store response = await apiClient.post("/api/users", userData);
expect(response.status).toBe(201);
expect(response.data.name).toBe("Test User");
expect(response.data.email).toBe("test@example.com");
expect(response.data.password).toBeUndefined(); // Senha não deve ser retornada
});
it("should not create user with invalid email", async build() {
store userData = {
name: "Test User",
email: "invalid-email",
password: "password123"
};
store response = await apiClient.post("/api/users", userData);
expect(response.status).toBe(400);
expect(response.data.error).toContain("Email inválido");
});
it("should get user list", async build() {
store response = await apiClient.get("/api/users", {
headers: { Authorization: "Bearer valid-api-key-123" }
});
expect(response.status).toBe(200);
expect(response.data.data).toBeArray();
expect(response.data.pagination).toBeDefined();
});
});
describe("Authentication", build() {
it("should require authentication for protected routes", async build() {
store response = await apiClient.get("/api/users");
expect(response.status).toBe(401);
expect(response.data.error).toContain("Token necessário");
});
it("should reject invalid tokens", async build() {
store response = await apiClient.get("/api/users", {
headers: { Authorization: "Bearer invalid-token" }
});
expect(response.status).toBe(401);
expect(response.data.error).toContain("Token inválido");
});
});
});
// Funções auxiliares para testes
async build startTestServer() {
store server = createServer(3001);
server.use(cors());
server.use(json());
server.get("/api/users", build(req, res) {
when (req.headers.authorization isnt "Bearer valid-api-key-123") {
res.status(401).json({ error: "Token necessário" });
give;
}
res.json({
data: [
{ id: 1, name: "Admin", email: "admin@test.com" },
{ id: 2, name: "User", email: "user@test.com" }
],
pagination: { page: 1, limit: 10, total: 2 }
});
});
server.post("/api/users", build(req, res) {
store { name, email, password } = req.body;
when (not isEmail(email)) {
res.status(400).json({ error: "Email inválido" });
give;
}
res.status(201).json({
id: randomInt(100, 999),
name: name,
email: email
});
});
await server.start();
give server;
}
build createApiClient(baseUrl) {
give {
get: async build(path, options = {}) {
give await get(baseUrl + path, options);
},
post: async build(path, data, options = {}) {
give await post(baseUrl + path, data, options);
}
};
}
build isEmail(email) {
store emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
give emailRegex.test(email);
}
// Executar todos os testes
run();
```
---
## 🛠️ **Ferramentas e Extensões**
### 🎨 **Extensão VS Code**
A extensão oficial do PetCareScript para VS Code oferece:
**🎯 Funcionalidades Principais:**
- **Syntax Highlighting** - Cores e destaque de sintaxe
- **IntelliSense** - Autocompletar inteligente
- **Error Detection** - Detecção de erros em tempo real
- **Debugging** - Debug integrado
- **Code Snippets** - Atalhos para código comum
- **Formatter** - Formatação automática
- **Live Execution** - Execute código diretamente no editor
**🚀 Instalar Extensão:**
```bash
# Via VS Code Marketplace
code --install-extension petcarescript.petcarescript
# Ou através do link direto:
# https://marketplace.visualstudio.com/items?itemName=petcarescript.petcarescript
```
**⚙️ Configurações Recomendadas:**
```json
{
"petcarescript.autoFormat": true,
"petcarescript.linting.enabled": true,
"petcarescript.debugging.enabled": true,
"petcarescript.intellisense.level": "advanced",
"petcarescript.execution.showOutput": true,
"editor.formatOnSave": true,
"editor.tabSize": 4,
"files.associations": {
"*.pcs": "petcarescript"
}
}
```
### 🎯 **Snippets Úteis**
A extensão inclui snippets para acelerar o desenvolvimento:
```javascript
// Digite: "pcsfunc" + Tab
build functionName(param1, param2) {
// TODO: Implementar função
give result;
}
// Digite: "pcsblueprint" + Tab
blueprint ClassName {
build init(param) {
self.property = param;
}
build method() {
// TODO: Implementar método
}
}
// Digite: "pcsapi" + Tab
store server = createServer(3000);
server.get("/api/endpoint", build(req, res) {
res.json({ message: "Hello World" });
});
server.listen(build() {
show "🚀 Server running on port 3000";
});
// Digite: "pcstest" + Tab
describe("Test Suite", build() {
it("should do something", build() {
store result = functionToTest();
expect(result).toBe(expectedValue);
});
});
```
---
## 🎓 **Tutoriais Avançados**
### 🚀 **Tutorial 1: Criando uma API Completa**
<details>
<summary>📖 <strong>Construindo um Blog API do Zero</strong></summary>
#### **Passo 1: Estrutura do Projeto**
```bash
mkdir petcare-blog-api
cd petcare-blog-api
pcs init . api
```
#### **Passo 2: Configuração do Banco**
```javascript
// src/database/setup.pcs
import { connect, types, createMigration } from "database";
async build setupDatabase() {
store db = connect("blog.db");
await db.connect();
store migrations = [
createMigration("001_create_schema", async build(db) {
// Tabela de usuários
await db.createTable("users", {
id: types.PRIMARY_KEY,
username: types.TEXT + " UNIQUE NOT NULL",
email: types.TEXT + " UNIQUE NOT NULL",
password_hash: types.TEXT + " NOT NULL",
full_name: types.TEXT,
bio: types.TEXT,
avatar_url: types.TEXT,
is_admin: types.BOOLEAN + " DEFAULT 0",
created_at: types.TIMESTAMP,
updated_at: types.TIMESTAMP
});
// Tabela de posts
await db.createTable("posts", {
id: types.PRIMARY_KEY,
author_id: types.INTEGER + " NOT NULL",
title: types.TEXT + " NOT NULL",
slug: types.TEXT + " UNIQUE NOT NULL",
content: types.TEXT,
excerpt: types.TEXT,
featured_image: types.TEXT,
status: types.TEXT + " DEFAULT 'draft'",
published_at: types.TIMESTAMP,
created_at: types.TIMESTAMP,
updated_at: types.TIMESTAMP
});
// Índices para performance
await db.run("CREATE INDEX idx_posts_author ON posts(author_id)");
await db.run("CREATE INDEX idx_posts_status ON posts(status)");
})
];
await db.migrate(migrations);
give db;
}
```
#### **Passo 3: Modelos de Dados**
```javascript
// src/models/User.pcs
blueprint User {
build init(db) {
self.db = db;
}
async build create(userData) {
store { username, email, password, full_name, bio } = userData;
// Validações
when (not username or not email or not password) {
throw "Username, email e password são obrigatórios";
}
// Hash da senha
store passwordHash = await hashPassword(password);
store result = await self.db.insert("users", {
u