huella 0.1.0

data/lib/huella/alimento.rb

@@ -0,0 +1,112 @@
+=begin
+    Representa un alimento con su nombre y sus
+    * valores energéticos: Proteinas carbohidratos y lipidos
+    * valores ambientales: Gases de efecto invernadero (gei) y uso de terreno
+=end
+class Alimento
+
+    include Comparable
+
+    attr_reader :nombre, :proteinas, :carbohidratos, :lipidos, :gei, :terreno
+
+    def initialize(nombre, proteinas, carbohidratos, lipidos, gei, terreno)
+        @nombre = nombre
+        @proteinas = proteinas
+        @carbohidratos = carbohidratos
+        @lipidos = lipidos
+        @gei = gei
+        @terreno = terreno
+    end
+
+    #Retorna el Alimento formateado
+    def to_s
+        "[#{@nombre} [#{@proteinas} #{@carbohidratos} #{@lipidos}] [#{@gei} #{@terreno}]]"
+    end
+
+    #Define la proporcion de cada nutriente en el aporte energético
+    def getValorEnergetico
+        ( (proteinas * 4.00) + (carbohidratos * 4.00) + (lipidos * 9.00) ).round(2)
+    end
+
+    #Retorna el valor energético dependiendo de la cantidad de gramos del alimento
+    def getValorEnergeticoConGramos(cantidad)
+        ( (getValorEnergetico * cantidad) / 100.0 ).round(2)
+    end
+
+    #Compara cada Alimento según su valor energético
+    def <=>(other)
+        #-1 si left <  right
+        # 0 si left == right
+        # 1 si left >  right
+        self.getValorEnergetico <=> other.getValorEnergetico
+    end
+
+    #Dos Alimentos son iguales si tienen los mismos atributos
+    def ==(other)
+        (@nombre == other.nombre) && (@proteinas == other.proteinas) && 
+            (@carbohidratos == other.carbohidratos) && (@lipidos == other.lipidos) && 
+            (@gei == other.gei) && (@terreno == other.terreno) 
+    end
+
+    #Retorna un índice de energía según la cantidad en gr del alimento
+    def getIndiceEnergia(cantidad)
+
+        energia = self.getValorEnergetico * cantidad
+
+        if(energia < 670)
+            return 1
+        elsif(energia < 830)
+            return 2
+        else
+            return 3
+        end
+
+    end
+
+    #Como el valor de gei está en 1 Kg, se hace la equivalencia a 100 gr
+    def getGeix100gr
+        (@gei * 100).round(2)
+    end
+
+    #Retorna un índice de huella de carbono según la cantidad en gr del alimento
+    def getIndiceHuellaCarbono(cantidad)
+
+        gases = self.getGeix100gr * cantidad
+
+        if(gases < 800)
+            return 1
+        elsif(gases < 1200)
+            return 2
+        else
+            return 3
+        end
+
+    end
+
+    #Retorna un nuevo Alimento resultado de la suma de otros dos alimentos
+    def +(other)
+
+        proNew = (other.proteinas + @proteinas).round(2)
+        carboNew = (other.carbohidratos + @carbohidratos).round(2)
+        lipNew = (other.lipidos + @lipidos).round(2)
+        geiNew = (other.gei + @gei).round(2)
+        terNew = (other.terreno + @terreno).round(2)
+
+        Alimento.new("combinado", proNew, carboNew, lipNew, geiNew, terNew)
+
+    end
+
+    #Retorna un nuevo Alimento resultado de la multiplicación de un Alimento por un escalar
+    def *(value)
+
+        proNew = (@proteinas * value).round(2)
+        carboNew = (@carbohidratos * value).round(2)
+        lipNew = (@lipidos * value).round(2)
+        geiNew = (@gei * value).round(2)
+        terNew = (@terreno * value).round(2)
+
+        Alimento.new(@nombre, proNew, carboNew, lipNew, geiNew, terNew)
+
+    end
+    
+end

data/lib/huella/lista.rb

@@ -0,0 +1,275 @@
+=begin
+    Es una abstración de una lista doblemente enlazada, es decir se puede recorrer en ambos
+    sentidos. En otras palabras, se puede ver como una aproximación de array. 
+    Tiene un puntero a cada extremo de la lista:
+    * Puntero al nodo cabeza
+    * Puntero al nodo cola
+=end
+class Lista 
+
+    include Enumerable
+    
+    attr_reader :head, :tail
+
+    def initialize(head = nil, tail = nil, arrayElementos = nil)
+        @head = head
+        @tail = tail
+
+        if(arrayElementos != nil)
+            self.pushAll(arrayElementos)
+        end
+    end
+
+    #Inserta un elemento por la cola
+    def push (elemento)
+        nodoNuevo = Nodo.new(elemento)
+
+        #La lista está vacia
+        if(@head == nil)
+            @head = nodoNuevo 
+        else
+            #Agrega el nuevo nodo al final de una lista no vacia
+            @tail.next=(nodoNuevo)
+            nodoNuevo.prev=(@tail)
+        end
+
+        #Actualiza la cola
+        @tail = nodoNuevo
+
+    end
+
+    #Inserta varios elementos por la cola
+    def pushAll(arrayElementos)
+        arrayElementos.each do |elemento|
+            push(elemento)
+        end
+    end
+    
+    #Inserta un elemento por la cabeza
+    def unshift (elemento)
+
+        nodoNuevo = Nodo.new(elemento)
+
+        #La lista está vacia
+        if(@head == nil)
+            @tail = nodoNuevo
+        else
+            #Agrega el nuevo nodo al principio de una lista no vacia
+            nodoNuevo.next=(@head)
+            @head.prev=(nodoNuevo)
+        end
+
+        #Actualiza la cabeza
+        @head = nodoNuevo
+
+    end
+
+    #Extae el último elemento
+    def pop
+
+        oldTail = @tail
+        
+        #Existen mínimo 2 nodos
+        if( (@head != nil) && (@head.next != nil) )
+            @tail = @tail.prev
+            @tail.next=(nil)
+            oldTail.prev=(nil)
+        #Existe un solo nodo o ninguno
+        else
+            @head = nil
+            @tail = nil
+        end
+
+        oldTail
+
+    end
+
+    #Extae el primer elemento
+    def shift
+
+        oldHead = @head
+        
+        #Existen mínimo 2 nodos
+        if( (@head != nil) && (@head.next != nil) )
+            @head = @head.next
+            @head.prev=(nil)
+            oldHead.next=(nil)
+        #Existe un solo nodo o ninguno
+        else
+            @head = nil
+            @tail = nil
+        end
+
+        oldHead
+
+    end
+
+    #Accede a un elemento dada la posición
+    def at(pos)
+
+        temp = nil
+
+        #En caso de que no exista la posición, se devuelve el valor nil
+        self.each_with_index do |elemento, index|
+            if(index == pos)
+                temp = elemento
+                break
+            end
+        end
+
+        temp
+
+    end
+
+    #Dos listas son iguales si tienen exactamente los mismos elementos y en el mismo orden
+    def ==(other)
+
+        if(self.cantNodos != other.cantNodos)
+            return false
+        else
+            self.each_with_index do |elemento, index|
+                if(elemento != other.at(index))
+                    return false
+                end
+            end
+        end
+
+        return true
+
+    end
+
+    #Retorna verdadero si la lista está vacia, en otro caso retorna falso
+    def isVacia
+        if(cantNodos == 0)
+            return true
+        end
+
+        return false
+    end
+
+    #Devuelve la cantidad de elementos
+    def cantNodos
+        total = 0
+        temp = @head
+
+        while(temp != nil)
+            temp = temp.next
+            total += 1
+        end
+
+        total
+    
+    end
+
+    #Retorna en porcenataje el aporte de proteinas en el valor energético
+    def getProcentajeProteinas
+
+        totalProteinas = 0
+        totalValorEnergetico = 0
+        temp = @head
+
+        while(temp != nil)
+            totalProteinas += temp.value.proteinas
+            totalValorEnergetico += temp.value.getValorEnergetico
+            temp = temp.next
+        end
+
+        ( (totalProteinas * 100 * 4) / totalValorEnergetico ).round(2)
+
+    end
+
+    #Retorna en porcenataje el aporte de carbohidratos en el valor energético
+    def getProcentajeCarbohidratos
+
+        totalCarbohidratos = 0
+        totalValorEnergetico = 0
+        temp = @head
+
+        while(temp != nil)
+            totalCarbohidratos += temp.value.carbohidratos
+            totalValorEnergetico += temp.value.getValorEnergetico
+            temp = temp.next
+        end
+
+        ( (totalCarbohidratos * 100 * 4) / totalValorEnergetico ).round(2)
+
+    end
+
+    #Retorna en porcenataje el aporte de lípidos en el valor energético
+    def getProcentajeLipidos
+
+        totalLipidos = 0
+        totalValorEnergetico = 0
+        temp = @head
+
+        while(temp != nil)
+            totalLipidos += temp.value.lipidos
+            totalValorEnergetico += temp.value.getValorEnergetico
+            temp = temp.next
+        end
+
+        ( (totalLipidos * 100 * 9) / totalValorEnergetico ).round(2)
+
+    end
+
+    #Retorna los gases de efecto invernadero producidos en un día
+    def getGeiDiario
+
+        totalGei = 0
+        temp = @head
+
+        while(temp != nil)
+            totalGei += temp.value.gei
+            temp = temp.next
+        end
+
+        totalGei.round(2)
+
+    end
+
+    #Retorna los gases de efecto invernadero producidos en un año
+    def getGeiAnual
+        (getGeiDiario * 365).round(2)
+    end
+
+    #Retorna el uso de terreno en un año
+    def getTerrenoTotal
+
+        totalTerreno = 0
+        temp = @head
+
+        while(temp != nil)
+            totalTerreno += temp.value.terreno
+            temp = temp.next
+        end
+
+        totalTerreno.round(2)
+
+    end
+
+    #Retorna la Lista formateada
+    def to_s
+
+        salida = []
+
+        self.each do |elemento|
+            salida << elemento
+        end
+
+        "[" + salida.join(" <-> ") + "]"
+
+    end
+
+    #Implementación del método each para utilizar los demás métodos del módulo enumerable
+    def each
+
+        temp = @head
+        
+        while(temp != nil)
+          yield temp.value
+          temp = temp.next
+        end
+
+    end
+
+end

data/lib/huella/menu_dsl.rb

@@ -0,0 +1,92 @@
+class MenuDSL
+
+    def initialize(nombre, &block)
+
+        @nombre = nombre
+        @descripcion = ""
+        @listaPlatos = []
+        @listaPrecios = []
+        @precioTotal = 0
+
+        if block_given?
+
+            # Baja y sube para analizar cada linea
+            if block.arity == 1
+                yield self
+            # Solo sube una vez, todo el bloque se interpreta
+            else
+                instance_eval(&block)
+            end
+
+        end
+        
+    end
+
+    # Asignar una descripción al menú
+    def descripcion(desc = "")
+        @descripcion = desc
+    end
+
+    # Valida si un componente tiene las características válidas
+    def componenteValido(comp)
+
+        if !comp[:plato]
+            return 0
+        elsif !comp[:precio]
+            return 0
+        end
+
+        return 1
+
+    end
+
+    # Asignar un componente a partir de un hash
+    def componente(comp = {})
+
+        if componenteValido(comp) == 1
+
+            @listaPlatos << comp[:plato]
+            @listaPrecios << comp[:precio]
+
+        end
+
+    end
+
+    # Asignar el precio del menú
+    def precio(prec = 0)
+        @precioTotal = prec
+    end
+
+    # Formatea el menú en un string
+    def to_s 
+
+        cantDecimales = '%.2f'
+        
+        output = "#{@nombre}\n"
+        #output << "#{'=' * @nombre.size}\n"
+        output << "Descripcion: #{@descripcion}\n"
+        output << "Precio: #{cantDecimales % @precioTotal}\n"
+        output << "============\n\n"
+
+        output << "Platos:\n\n"
+        
+        @listaPlatos.each_with_index do |plato, index|
+            energia = plato.getValorEnergeticoPlato()
+            gei = plato.getGeiDiarioPlato()
+
+            output << "#{index + 1}) #{plato.nombre}\n"
+            
+            alimentos =  plato.listaAlimentos
+            nombresAlimentos = alimentos.map{|alim| alim.nombre}
+            output << "Componentes: #{nombresAlimentos.join(', ')}\n"
+
+            output << "Valor Nutricional: #{cantDecimales % energia} kcal\n"
+            output << "Valor Ambiental: #{cantDecimales % gei} kgCO2\n"
+            output << "Precio: #{cantDecimales % @listaPrecios[index]}\n\n"
+        end
+
+        output
+
+    end
+
+end

data/lib/huella/nodo.rb

@@ -0,0 +1,7 @@
+=begin
+    Define la estructura de un nodo
+    * Valor
+    * Puntero al nodo proximo
+    * Puntero al nodo previo
+=end
+Nodo = Struct.new(:value, :next, :prev)

data/lib/huella/plato_ambiental.rb

@@ -0,0 +1,100 @@
+=begin
+    Es una clase hija de PlatoNutricional, encapsula los métodos ambientales de un Plato.
+    Al igual que en la clase padre, se define un nombre, lista de alimentos y lista de
+    cantidades, que son inicializadas en el initialize de la clase padre con super
+=end
+class PlatoAmbiental < PlatoNutricional
+
+    def initialize(nombre, listaAlimentos, listaCantidades)
+        super(nombre, listaAlimentos, listaCantidades)
+    end
+
+    #Retorna los gases de efecto invernadero producidos en un día por un plato
+    def getGeiDiarioPlato
+
+        geiTotal = 0
+
+        alimentoWithCantidad = @listaAlimentos.zip(@listaCantidades)
+        
+        alimentosMultiplicados = alimentoWithCantidad.map do |alimento, cantidad|
+            alimento * cantidad
+        end
+
+        geiTotal = alimentosMultiplicados.reduce(:+).gei
+        geiTotal.round(2)
+
+    end
+
+    #Retorna los gases de efecto invernadero producidos en un año por un plato
+    def getGeiAnualPlato
+        (self.getGeiDiarioPlato * 365).round(2)
+    end
+    
+    #Retorna el uso de terreno producido en un año por un plato
+    def getTerrenoPlato
+
+        terrenoTotal = 0
+
+        @listaAlimentos.each_with_index do |alimento, index|
+            terrenoTotal += alimento.terreno * @listaCantidades.at(index)
+        end
+
+        terrenoTotal.round(2)
+
+    end
+
+    #Se calcula la relación GEI/valorEnegertico y la retorna formateada
+    def getEficienciaEnergeticaFormateada
+
+        salida = []
+        eficienciaTotal = 0
+
+        @listaAlimentos.each_with_index do |elemento, index|
+            energia = @listaCantidades.at(index) * elemento.getValorEnergetico
+            gei = @listaCantidades.at(index) * elemento.gei
+            
+            #GEI pruducidos por 1 kcal de un alimento
+            eficiencia = (gei/energia).round(2)
+            eficienciaTotal += eficiencia
+
+            salida << eficiencia
+        end
+
+        "[" + @nombre + " " + eficienciaTotal.round(2).to_s + " [" + salida.join(" ") + "]]"
+
+    end
+
+    #Compara dos Platos según la huella nutricional
+    def <=>(other)
+        #-1 si left <  right
+        # 0 si left == right
+        # 1 si left >  right
+        self.huellaNutricional <=> other.huellaNutricional
+    end
+
+
+    #Retorna un número en el rango [1,3] que corresponde a la huella nutricional de un plato
+    def huellaNutricional
+
+        alimentoWithCantidad = @listaAlimentos.zip(@listaCantidades)
+
+        #Energia
+        energia = alimentoWithCantidad.map do |alimento, cantidad| 
+            alimento.getIndiceEnergia(cantidad)
+        end
+
+        #Huella Carbono
+        carbono = alimentoWithCantidad.map do |alimento, cantidad| 
+            alimento.getIndiceHuellaCarbono(cantidad)
+        end
+
+        #Sumatorio
+        dividendo = energia.reduce(:+) + carbono.reduce(:+)
+        divisor = energia.size * 2.0
+        #Nota: Se divide entre la cantidad de indices
+
+        (dividendo / divisor).round(2)
+
+    end
+
+end

data/lib/huella/plato_dsl.rb

@@ -0,0 +1,89 @@
+class PlatoDSL
+
+    def initialize(nombre, &block)
+
+        @nombre = nombre
+        @listaAlimentos = []
+        @listaCantidades = []
+
+        if block_given?
+
+            # Baja y sube para analizar cada linea
+            if block.arity == 1
+                yield self
+            # Solo sube una vez, todo el bloque se interpreta
+            else
+                instance_eval(&block)
+            end
+
+        end
+
+    end
+
+    # Valida que un hash tenga todos los atributos para crear un alimento valido
+    def alimentoValido(alim)
+
+        if !alim[:nombre]
+            return 0
+        elsif !alim[:proteinas]
+            return 0
+        elsif !alim[:carbohidratos]
+            return 0
+        elsif !alim[:lipidos]
+            return 0
+        elsif !alim[:gei]
+            return 0
+        elsif !alim[:terreno]
+            return 0
+        elsif !alim[:gramos]
+            return 0
+        end
+
+        return 1
+
+    end
+
+    # Crea un alimento a partir de un DLS
+    def alimento(alim = {})
+
+        # Alimento valido
+        if alimentoValido(alim) == 1
+            nom = alim[:nombre]
+            pro = alim[:proteinas]        
+            car = alim[:carbohidratos]        
+            lip = alim[:lipidos]      
+            gei = alim[:gei]      
+            ter = alim[:terreno]
+
+            alimento = Alimento.new(nom, pro, car, lip, gei, ter)
+            @listaAlimentos << alimento
+
+            @listaCantidades << alim[:gramos]
+        end
+
+    end
+
+    # Formatea el menú en un string
+    def to_s 
+
+        cantDecimales = '%.2f'
+        
+        output = "#{@nombre}\n"
+        output << "#{'=' * @nombre.size}\n\n"
+
+        output << "Ingedientes:\n\n"
+
+        @listaAlimentos.each_with_index do |alim, index|
+            energia = alim.getValorEnergeticoConGramos(@listaCantidades[index])
+
+            output << "#{index + 1}) #{alim.nombre}\n"
+            output << "Cantidad: #{cantDecimales % @listaCantidades[index]}\n"
+            output << "Valor Nutricional: #{cantDecimales % energia} kcal\n"
+            output << "Valor Ambiental: #{cantDecimales % alim.gei} kgCO2\n\n"
+        end
+
+        output
+
+    end
+
+end