Initial commit

.github/workflows/ci.yml

@@ -0,0 +1,14 @@
+name: build
+
+on: [push, pull_request]
+jobs:
+  wollok-ts:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - run: |
+          wget -O wollok-ts-cli https://github.com/uqbar-project/wollok-ts-cli/releases/latest/download/wollok-ts-cli-linux-x64
+          chmod a+x ./wollok-ts-cli
+          ./wollok-ts-cli test --skipValidations -p ./
+        shell: bash

1_objetos.md

@@ -0,0 +1,71 @@
+## Parte 1: Golosinas
+De cada **golosina** interesan: el _precio_, el _sabor_, su _peso_ en gramos y si _contiene gluten_. <br>
+Además, cada vez que una golosina _recibe un mordisco_ se reduce la cantidad de gramos
+que posee.
+
+
+#### Bombón
+Vale 5 pesos y pesa inicialmente 15 gramos. Su gusto es frutilla. Es libre
+de gluten. <br> 
+Cuando recibe un mordisco, pierde un 20 % de su peso + 1 gramo extra 
+(debido a que parte del relleno cremoso se pierde al caer al suelo). 
+O sea, su nuevo peso se calcula como `(peso * 0.8) - 1`. 
+
+#### Alfajor 
+Vale 12 pesos y pesa inicialmente 300 gramos. Su gusto es chocolate. No es libre de gluten.  
+Cuando recibe un mordisco, pierde el 20 % de su peso (o sea, su nuevo peso se calcula como `peso * 0.8`).
+
+#### Caramelo 
+Vale 1 peso y pesa inicialmente 5 gramos. Su gusto es frutilla. Es libre de gluten.   
+Cuando recibe un mordisco, pierde 1 gramo.
+
+#### Chupetín 
+Vale 2 pesos y pesa inicialmente 7 gramos. Su gusto es naranja. Es libre de gluten.  
+Cuando recibe un mordisco, pierde el 10 % de su peso, a excepción de que su peso actual sea menor a 2 gramos: en tal caso, no pierde nada.
+
+#### Oblea 
+Vale 5 pesos y pesa inicialmente 250 gramos. Su gusto es vainilla. No es libre de gluten.  
+Al recibir un mordisco pierde peso, en una cantidad que depende del peso actual: si es mayor a 70 gramos pierde el 50 % de su peso, en caso contrario, el 25 %.
+
+#### Chocolatín
+El peso inicial es desconocido, lo asigna el usuario. El precio es de $0,50 por cada gramo de peso inicial. No es libre de gluten. Obviamente, su gusto es chocolate.   
+Pierde 2 gramos por mordisco.   
+**¡Atención!** El precio es según el _peso inicial_, no debe cambiar con los mordiscos.
+
+#### Golosina bañada
+Se arma a partir de una _golosina de base_. <br>
+El peso inicial es el de la golosina de base más 4 gramos que es lo que pesa el bañado. El precio es el de la golosina de base más 2 pesos. El gusto es el de la golosina de base. 
+De la misma manera, es libre de gluten si lo es su golosina base.   
+Con cada mordisco se da un mordisco a la golosina de base. Además, en el primer mordisco pierde 2 gramos de
+bañado, y en el segundo los otros dos.
+
+#### Pastilla tutti-frutti
+Pesa inicialmente 5 gramos. 
+La pastilla puede ser libre de gluten o no (se configura). Si es libre de gluten el precio es $7; si no, es de $10.  
+En cada mordisco cambia el sabor, pasa de frutilla a chocolate, de ahí a naranja, de ahí vuelve a frutilla. 
+
+<br> 
+
+## Parte 2: Mariano
+
+Crear el objeto `mariano` con la capacidad de comprar golosinas, hacer cosas con las golosinas que tiene, y responder a consultas sobre las mismas. En particular, debe entender todos los mensajes que siguen:
+* `comprar(unaGolosina)` : agrega una golosina a la bolsa de golosinas compradas.
+* `desechar(unaGolosina)` : desecha la golosina escogida de la bolsa de golosinas.
+* `probarGolosinas()` : le da un mordisco a todas las golosinas dentro de la bolsa de golosinas compradas.
+* `hayGolosinaSinTACC()` : indica si hay al menos una golosina sin gluten en la bolsa de golosinas compradas.
+* `preciosCuidados()` : indica si todas las golosinas compradas tienen un precio menor o igual a 10 pesos.
+* `golosinaDeSabor(unSabor)` : devuelve _la primer golosina_ que encuentra en la bolsa del sabor escogido.
+* `golosinasDeSabor(unSabor)` : devuelve _las golosinas_ que encuentre dentro de la bolsa del sabor escogido.
+* `sabores()` : que devuelve los sabores de las golosinas de la bolsa, idealmente sin repetidos. <br> 
+  P.ej. aunque Mariano tenga tres golosinas de sabor naranja, en lo que devuelve `sabores()` el naranja debería aparecer una sola vez. <br> Una forma de resolver esto es usando **conjuntos**; revolver en el apunte sobre colecciones y closures: [https://objetos1wollokunq.gitlab.io/material/guia-colecciones-basicas.pdf](https://objetos1wollokunq.gitlab.io/material/guia-colecciones-basicas.pdf).
+* `golosinaMasCara()` : devuelve la golosina mas cara en la bolsa de golosinas compradas.
+* `pesoGolosinas()` : devuelve el peso de la bolsa de golosinas compradas, o sea, la suma del peso de cada golosina. 
+
+Además, se deben contemplar dos situaciones relacionadas con _Juliana_, la pareja actual de Mariano. 
+* Juliana critica a Mariano, pero siempre que puede le quita alguna golosina si es de las que a ella le gusta, y se enoja por las que faltan. <br>
+Lograr que a Mariano se le pueda preguntar `golosinasFaltantes(golosinasDeseadas)` , donde `golosinasDeseadas` es una colección de golosinas. Debe devolver las golosinas que están entre las `golosinasDeseadas`, y que Mariano **no** compró.
+* A veces Juliana tiene antojos por gustos gustos especiales. <br> 
+Lograr que a Mariano se le pueda preguntar `gustosFaltantes(gustosDeseados)`, que es una consulta similar a la anterior, pero donde `gustosDeseados`  es una colección de _gustos_. <br>
+Debe devolver los gustos que están entre los `gustosDeseados`, y que no están cubiertos por ninguna golosina de las que tiene Mariano.
+
+

1_tests.md

@@ -0,0 +1,19 @@
+# Tests sobre las partes 1 y 2
+
+## Tests de golosinas
+Para cada golosina definida en la parte 1, salvo la golosina bañada (bombón, alfajor, caramelo, chupetín, oblea, chocolatín, pastilla tutti-frutti) definir un test en el que 
+- se verifique que el peso inicial, el precio y el gusto sean los indicados en el enunciado; y que es, o no, libre de gluten, de acuerdo también a lo que se indica en el enunciado. 
+Para el chocolatín hacer dos comprobaciones, una con 40 gramos de peso inicial y la otra con 100.
+Para la pastilla tutti-frutti, hacer dos comprobaciones, una en la que es libre de gluten y la otra en que no.
+- se le den dos mordiscos a la golosina, y se validen los cambios esperados en peso o sabor después de cada uno. Para chocolatín y pastilla tutti-frutti usar las dos variantes descriptas en el ítem anterior. Para la oblea, que sean tres mordiscos en lugar de dos.
+
+Para la golosina bañada, hacer las mismas comprobaciones, para tres casos distintos: 
+- bañando una pastilla tutti-frutti.
+- bañando un chocolatín.
+- bañando un chupetín.
+
+<br> 
+
+## Tests de Mariano
+Armar un test en el que Mariano compre el chocolatin, el caramelo y el bombón. Probar cada método descripto en el enunciado. 
+En particular, para `golosinasFaltantes` probar con `#{alfajor, bombon, chocolatin, chupetin}`, y para `gustosFaltantes`, con `#{"melón", "chocolate", "frutilla" , "vainilla"}`.

2_clases_herencia.md

@@ -0,0 +1,93 @@
+## Parte 3: muchas golosinas
+
+A partir de la solución desarrollada en las partes 1 y 2, hacer las modificaciones necesarias para que Mariano pueda comprar varios bombones, chocolatines, caramelos, alfajores, chupetines, obleas, golosinas bañadas y/o pastillas tuttifruti.
+
+Resolver adecuadamente los casos en los que hay que pasar parámetros en la inicialización (el peso del chocolatín y la golosina a bañar).
+
+<br>
+
+
+### Bañar Golosina
+
+Hacer que Mariano entienda el mensaje `baniar(unaGolosina)`. 
+El método construye una nueva golosina bañada y la agrega a la colección de las golosinas que compró Mariano.
+
+Pensar, haciendo un diagrama de objetos, qué pasa si:
+1. la golosina ya era parte de la colección.
+1. se baña una golosina ya bañada.
+
+<br>
+
+## Parte 4: más variantes de golosinas 
+
+### Caramelos de distintos sabores
+Hacer que pueda haber caramelos de frutilla, naranja, y chocolate. Cuando se construye el caramelo se le indica de que gusto es.
+
+
+<!--- herencia de clase concreta con redefinicion --->
+
+### Bombones duros
+Los bombones duros son bombones (tienen las mismas reglas para el precio y gusto) pero cuando reciben un mordisco, en lugar de comportarse como el resto de los bombones, pierden el 10% de su peso
+
+Indicar en cuál clase se encuentra el método que se ejecuta en cada caso, detallando el recorrido que realiza el method lookup.
+
+```
+var bombon = new Bombon() 
+bombon.mordisco() 
+bombon.peso() 
+bombon = new BombonDuro() 
+bombon.mordisco() 
+bombon.peso() 
+```
+
+<!--- herencia con redefinicion y super para hacer otra cosa --->
+
+### Caramelos con corazón de chocolate (Rellenos)
+Los caramelos con corazón de chocolate son caramelos que al recibir un mordisco, además de comportarse como todos los caramelos cambian su sabor a chocolate
+
+Indicar en cuál clase se encuentra el método que se ejecuta en cada caso, detallando el recorrido que realiza el method lookup.	
+
+```
+var caramelo = new Caramelo() 
+caramelo.mordisco() 
+caramelo.peso() 
+caramelo.sabor() 
+caramelo = new CarameloRelleno() 
+caramelo.mordisco() 
+caramelo.peso() 
+caramelo.sabor()
+```
+
+<!--- herencia con redefinicion y super para modificar el resultado. Ademas tiene una variable en la subclase --->
+
+### Obleas Crujientes
+Las obleas crujientes son como todas las obleas y cuando reciben un mordisco 
+pierden el peso que pierden todas las obleas (50% si el peso es mayor a 70g o 25% si es menor). Pero, en los primeros 3 mordiscos pierde 3 gramos adicionales.
+
+Indicar en cuál clase se encuentra el método que se ejecuta en cada caso, detallando el recorrido que realiza el method lookup.
+
+```
+var oblea = new Oblea() 
+oblea.mordisco() 
+oblea.peso() 
+oblea = new ObleaCrujiente() 
+oblea.mordisco() 
+oblea.peso() 
+```
+
+### Chocolatines VIP y  Chocolatines Premium
+Los chocolatines VIP, son como todos los chocolatines, pero se guardan en una heladera que aporta un coeficiente de humedad (un número entre 0 y 1). Este coeficiente está involucrado para el cálculo del peso: El peso de un chocolatin VIP es el peso que tendría un Chocolatín cualquiera: 
+`(pesoInicial - gramosConsumidos)` multiplicado por  `1 + humedad`. 
+
+Los chocolatines Premium son un tipo especial de chocolatines VIP que vienen con una cobertura especial que los hace más resistentes a la humedad. Por lo tanto, La humedad en estos chocolatines es la mitad de la humedad de los chocolatines VIP.
+
+Indicar en cuál clase se encuentra el método que se ejecuta en cada caso, detallando el recorrido que realiza el method lookup.
+
+```
+var chocolatin = new Chocolatin() 
+chocolatin.peso() 
+chocolatin = new ChocolatinVIP() 
+chocolatin.peso() 
+chocolatin = new ChocolatinPremium() 
+chocolatin.peso() 
+```

2_tests.md

@@ -0,0 +1,18 @@
+# Tests sobre las partes 3 y 4
+
+## Test de Mariano con varias golosinas del mismo tipo.
+
+Escribir un test en el cual Mariano compre dos bombones, un chocolatín de 50 gramos, un chocolatín de 10 gramos, dos chupetines bañados, y una pastilla tutti-frutti.
+Para bañar a los chupetines, usar el método `baniar(unaGolosina)` que debe agregarse a la definición de Mariano.
+
+Probar en particular los siguientes métodos definidos para Mariano: `probarGolosinas()`, `hayGolosinasSinTACC()`, `golosinasDeSabor(unSabor)` (probar con distintos sabores), `pesoGolosinas()`.
+
+Darle un mordisco al chocolatín de 50 gramos, y verificar cómo varía el `pesoGolosinas()`. Para esto, hay que quedarse con una referencia al chocolatín, _aparte_ de la que tiene la colección de Mariano. Armar un diagrama de objetos que refleje cómo quedan Mariano, sus golosinas, y la referencia desde el test al chocolatín.
+
+
+## Tests de variantes de golosinas
+
+Escribir un test para cada sección de código incluida en la parte 4 del enunciado, calculando cuál debe ser el peso (y el sabor en el caso de los caramelos rellenos) de las golosinas creadas.
+
+
+

README.md

@@ -0,0 +1,13 @@
+# Golosinas
+
+A Mariano le gustan mucho las golosinas. Juliana opina que exagera en el consumo de
+las mismas. Por eso Mariano decidió programar un modelo en objetos que le permitiera
+analizar su conducta.
+
+Vamos a realizar este modelo en dos etapas.
+- en la primera vamos a modelar cada golosina como un objeto (más precisamente, un _well-known object_ o **WKO**).
+- en la segunda vamos a incorporar los conceptos de _clase_ y _herencia_ para obtener un modelo más potente.
+
+Describimos en archivos separados los enunciados de cada etapa.
+
+

golosinas.wlk

@@ -0,0 +1,2 @@
+object bombon {
+}

package.json

@@ -0,0 +1,7 @@
+{
+  "name": "Golosinas_Parte1",
+  "version": "1.0.0",
+  "wollokVersion": "4.0.0",
+  "author": "leon",
+  "license": "ISC"
+}

testBombon.wtest

@@ -0,0 +1 @@
+