alimentos_diego_algomas 0.1.3

data/lib/alimentos.rb

@@ -0,0 +1,29 @@
+
+require "alimentos/version"
+require "alimentos/alimentos.rb"
+require "alimentos/list.rb"
+require "alimentos/plato.rb"
+require "alimentos/platoAmbiental.rb"
+require "alimentos/menu.rb"
+require "alimentos/dsl.rb"
+require "alimentos/dslmenu.rb"
+
+module Alimentos
+  class Error < StandardError; end
+  # Your code goes here...
+end
+module List 
+  class Error < StandardError; end
+end
+module Plato
+  class Error < StandardError;end
+end
+module Menu
+  class Error < StandardError;end
+end
+module Dsl
+  class Error < StandardError;end
+end
+
+
+

data/lib/alimentos/alimentos.rb

@@ -0,0 +1,36 @@
+##
+# Modulo donde se encuentra la clase de alimentos
+
+module Alimentos
+	##
+	# Clase alimentos donde se guardan las propiedades del mismo 
+	class Alimentos
+		include Comparable
+		attr_reader :nombre,:proteinas,:carbohidratos,:lipidos,:emisiones,:m2
+		def initialize (nombre,proteinas,carbohidratos,lipidos,emisiones,m2)
+			@nombre = nombre
+			@proteinas = proteinas
+			@carbohidratos = carbohidratos
+			@lipidos = lipidos
+			@emisiones = emisiones
+			@m2 = m2
+			
+		end
+		##
+		# Metodo que calcula las kcal de un alimento
+		def calorias()
+			kcal = (@proteinas*4)+(@lipidos*9)+(@carbohidratos*4)
+			kcal.round(2)
+		end
+		##
+		# Serializador de un alimento
+		def to_s()
+			"#{@nombre}"
+		end
+		##
+		# Permite comparar entre alimentos
+		def <=>(other)
+			calorias()<=> other.calorias()
+		end
+	end
+end

data/lib/alimentos/dsl.rb

@@ -0,0 +1,123 @@
+require "alimentos/list.rb"
+module Dsl
+    class Platodsl
+        include List
+        attr_accessor :nombre,:alimentos,:cantidades,:kcal
+        ##
+        # Esta clase es comparable entre ellas
+        include Comparable
+        def initialize(nombre,&block)
+            @nombre = nombre
+            @alimentos = List.new()
+            @cantidades = List.new()
+            
+            if block_given?
+                if block.arity == 1
+                    yield self
+                else
+                    instance_eval(&block)
+                end
+            end
+        end
+        def alimento(aliment, options={})
+            @alimentos.push(aliment)
+            @cantidades.push(options[:cantidad]) if options[:cantidad]
+            @kcal=calculoCalorico()
+        end
+        
+        ##
+        # Realiza el calculo de las calorias totales del plato
+        def calculoCalorico()
+            calorias = @alimentos.collect { |x| x.calorias()}
+            cantidades = @cantidades.collect{ |x| x}
+            for i in 0...cantidades.size() do
+                calorias[i]=calorias[i]*0.01*cantidades[i]
+            end
+            calorias.sum
+        end
+        ##
+        # Realiza el calculo del porcentaje de proteinas que tiene
+        def porproteinas()
+            proteinas = @alimentos.collect { |x| x.proteinas}
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...proteinas.size() do
+                proteinas[i] = proteinas[i]*cantidades[i]*0.01
+            end
+            ((proteinas.sum*4/@kcal)*100).round(2)
+        end
+            ##
+        # Realiza el calculo del porcentaje de lipidos que tiene
+        def porlipidos()
+            lipidos = @alimentos.collect { |x| x.lipidos}
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...lipidos.size() do
+                lipidos[i]=lipidos[i]*cantidades[i]*0.01
+            end
+            ((lipidos.sum*9/@kcal)*100).round(2)
+        end
+        def emisiones()
+            emisiones= @alimentos.collect{ |x| x.emisiones }
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...emisiones.size() do
+                emisiones[i]=emisiones[i]*cantidades[i]*0.01
+            end
+            (emisiones.sum).round(2)
+        end
+        ##
+        # Calcula los metros cuadrados que gasta cada plato
+        def m2()
+            m2= @alimentos.collect{ |x| x.m2}
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...m2.size() do
+                m2[i]=m2[i]*cantidades[i]*0.01
+            end
+            (m2.sum).round(2)
+        end
+        ##
+        # Realiza el calculo del porcentaje de carbohidratos que tiene
+        def porcarbohidratos()
+            carbohidratos = @alimentos.collect{ |x| x.carbohidratos }
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...carbohidratos.size() do
+                carbohidratos[i]=carbohidratos[i]*cantidades[i]*0.01
+            end
+            ((carbohidratos.sum*4/@kcal)*100).round(2)
+        end
+        def huella()
+            ienergia=0
+            icarbono=0
+            if @kcal<670
+				ienergia+=1
+			elsif @kcal > 830
+				ienergia+=3
+			else 
+				ienergia+=2
+			end
+			if emisiones()<800
+				icarbono+=1
+			elsif emisiones()>1200
+				icarbono+=3
+			else
+				icarbono+=2
+			end
+			huellapropia= (ienergia+icarbono)/2
+			huellapropia
+        end
+        ##
+        # Serializa el plato
+        def to_s()
+            output = "#{@nombre}:\n"
+            @alimentos.zip(@cantidades).each do |aliment,cantidad|
+                output<<"\t\t#{aliment}: #{cantidad}g\n"
+            end
+            output << "\t\tValor energético: #{@kcal}kcal\n"
+            output << "\t\tHuella: #{huella()}"
+            output
+        end
+        ##
+        # Permite comparar entre distintos platos según las kcal
+        def <=>(other)
+            @kcal<=>other.kcal
+        end
+    end
+end

data/lib/alimentos/dslmenu.rb

@@ -0,0 +1,60 @@
+module Dsl
+    class MenuDsl
+        attr_accessor :nombre,:platos,:precios
+        include List
+        def initialize(nombre, &block)
+            @nombre = nombre
+            @precios = List.new()
+            @platos = List.new()
+            if block_given?
+                if block.arity == 1
+                    yield self
+                else
+                    instance_eval(&block)
+                end
+            end
+        end
+
+        def plato(plate,options={})
+            @platos.push(plate)
+            @precios.push(options[:price]) if options[:price]
+        end
+        def precio()
+            @precios.collect{|x| x}.sum
+        end
+        def energetico()
+            @platos.collect{|x| x.kcal}.sum
+        end
+        def porproteinas()
+            @platos.collect{|x| x.porproteinas()}.sum
+        end
+        def porlipidos()
+            @platos.collect{|x| x.porlipidos()}.sum
+        end
+        def porcarbohidratos()
+            @platos.collect{|x| x.porcarbohidratos()}.sum
+        end
+        def m2()
+            @platos.collect{|x| x.m2()}.sum
+        end
+        def emisiones()
+            @platos.collect{|x| x.emisiones()}.sum
+        end
+        def to_s()
+            output = "#{@nombre}"
+            output << ":\n"
+            @platos.zip(@precios).each do |plato,precio|
+                output << "\t#{plato}\n"
+            end
+            output<< "Precio: #{precio()}\n"
+            output<< "Proteinas: #{porproteinas()}g\n"
+            output<< "Lipidos: #{porlipidos()}g\n"
+            output<< "Carbohidratos: #{porcarbohidratos()}g\n"
+            output<< "Kcal: #{energetico()}\n"
+            output<< "M2: #{m2()}\n"
+            output<< "Emisiones: #{emisiones()}\n"
+            output
+        end
+
+    end
+end

data/lib/alimentos/list.rb

@@ -0,0 +1,104 @@
+    ##
+    # Modulo lista donde se encuentra la clase lista y el diseño de un nodo
+module List
+    Node = Struct.new(:value,:next,:prev)
+    ##
+    # Clase lista donde se implementa una clase constituida por una lista doblemente enlazada de elementos
+    class List
+        ##
+        # Incluye el modulo enumerable para permitir la iteración sobre la clase
+        include Enumerable
+        attr_reader :head,:tail,:lenght
+        def initialize ()
+            @head = nil
+            @tail = nil
+            @lenght = 0
+        end
+        ##
+        # Permite insertar un valor en la cola
+        def push (valor)
+            toinsert = Node.new(valor,nil,nil)
+            if @lenght == 0
+                @lenght= @lenght+1
+                toinsert.next = nil
+                toinsert.prev = nil
+                @head = toinsert
+                @tail = toinsert
+            else
+                @lenght = @lenght+1
+                @tail.next = toinsert
+                toinsert.prev = @tail
+                toinsert.next = nil
+                @tail = toinsert
+            end
+        end
+        ##
+        # Permite insertar un array de elementos en la cola
+        def push_array(values)
+            values.each do |item|
+                toinsert = Node.new(item,nil,nil)
+                if @lenght == 0
+                    @lenght= @lenght+1
+                    toinsert.next = nil
+                    toinsert.prev = nil
+                    @head = toinsert
+                    @tail = toinsert
+                else
+                    @lenght = @lenght+1
+                    @tail.next = toinsert
+                    toinsert.prev = @tail
+                    toinsert.next = nil
+                    @tail = toinsert
+                end
+            end
+        end
+        ##
+        # Permite extraer la cabeza y la devuelve
+        def pop_head()
+            if @lenght == 1
+                aux = @head
+                @lenght = 0
+                @head = nil
+                @tail = nil 
+                return aux
+            elsif @lenght > 1 
+                aux = @head
+                @lenght = @lenght-1
+                @head = aux.next
+                return aux
+            else
+                return nil
+            end            
+        end
+        ##
+        # Permite extraer la cola y la devuelve ese elemento
+        def pop_tail()
+            if @lenght == 1
+                aux = @head
+                @lenght = 0
+                @head = nil
+                @tail = nil 
+                return aux
+            elsif @lenght > 1 
+                aux = @tail
+                @lenght = @lenght-1
+                @tail = aux.prev
+                return aux
+            else
+                return nil
+            end  
+        end
+        def each
+            aux = @head
+            while(!aux.nil?)
+                yield aux.value
+                aux = aux.next
+            end
+        end
+        ##
+        # Devuelve el tamaño de la lista
+        def size()
+            @lenght-1
+        end
+    end
+end

data/lib/alimentos/menu.rb

@@ -0,0 +1,62 @@
+    ##
+    # Modulo donde se encuentra la clase menú (practica 8)
+    # Actualemente en desuso
+module Menu
+    ##
+    # Clase Menu donde se almacenaban una lista con los platos y la suma calórica de os mismos
+    class Menu
+        attr_reader :nombre,:platos,:kcal,:proteinas,:lipidos,:carbohidratos
+        include Comparable,Enumerable
+        def initialize(nombre,platos)
+            @platos = List::List.new()
+            @platos.push_array(platos)
+            @nombre = nombre
+            @proteinas = getProteinas()
+            @lipidos = getLipidos()
+            @carbohidratos = getCarbohidratos()
+            @kcal = getKcal()
+        end
+        ##
+        # calcula las Kcal del menú
+        def getKcal()
+            kalorias = @platos.collect{|x| x.kcal}
+            (kalorias.sum).round(2)
+        end
+        ##
+        # Calcula la cantidad de lípidos
+        def getLipidos()
+            lipids = @platos.collect{|x| x.porlipidos()}
+            (lipids.sum/lipids.size()).round(2)
+        end
+        ##
+        # calcula la cantidad de proteinas
+        def getProteinas()
+            proteins = @platos.collect{|x| x.porproteinas()}
+            (proteins.sum/proteins.size()).round(2)
+        end
+        ##
+        # calcula la cantidad de carbohidratos
+        def getCarbohidratos()
+            carbs = @platos.collect{|x| x.porcarbohidratos()}
+            (carbs.sum/carbs.size()).round(2)
+        end        
+            ##
+            # Compara entre distintos menus por las kcal
+        def <=>(other)
+            kcal<=>other.kcal
+        end
+             ## Transforma en un strig el menú
+        def to_s
+            "Menu: #{@nombre}\n Proteinas: #{@proteinas}%\nCarbohidratos:#{@carbohidratos}%\nLipidos:#{@lipidos}%\nKcal:#{@kcal}"
+        end
+            ##
+            #Implementa el enumerable del menu
+        def each
+            aux = @platos.head
+            while(!aux.nil?)
+                yield aux.value
+                aux = aux.next
+            end
+        end
+    end
+end

data/lib/alimentos/plato.rb

@@ -0,0 +1,93 @@
+require "alimentos/list.rb"
+require "alimentos/alimentos.rb"
+##
+# Modulo donde se encuentran la clase plato y plato ambiental
+module Plato
+    ##
+    # Clase plato donde se encuentran los platos dormados por sus alimentos y sus cantidades
+    class Plato
+        include List
+        attr_reader :nombre,:alimentos,:cantidades,:kcal
+        ##
+        # Esta clase es comparable entre ellas
+        include Comparable
+        def initialize(nombre,alimentos,cantidades)
+            @nombre = nombre
+            @alimentos = List.new()
+            @cantidades = List.new()
+            @alimentos.push_array(alimentos)
+            @cantidades.push_array(cantidades)
+            @kcal = calculoCalorico()
+
+        end
+        ##
+        # Realiza el calculo de las calorias totales del plato
+        def calculoCalorico()
+            calorias = @alimentos.collect { |x| x.calorias()}
+            cantidades = @cantidades.collect{ |x| x}
+            for i in 0...cantidades.size() do
+                calorias[i]=calorias[i]*0.01*cantidades[i]
+            end
+            calorias.sum
+        end
+        ##
+        # Realiza el calculo del porcentaje de proteinas que tiene
+        def porproteinas()def huella()
+            ienergia=0
+            icarbono=0
+            if @kcal<670
+				ienergia+=1
+			elsif @kcal > 830
+				ienergia+=3
+			else 
+				ienergia+=2
+			end
+			if emisiones()<800
+				icarbono+=1
+			elsif emisiones()>1200
+				icarbono+=3
+			else
+				icarbono+=2
+			end
+			huellapropia= (ienergia+icarbono)/2
+			huellapropia
+        end
+            proteinas = @alimentos.collect { |x| x.proteinas}
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...proteinas.size() do
+                proteinas[i] = proteinas[i]*cantidades[i]*0.01
+            end
+            ((proteinas.sum*4/@kcal)*100).round(2)
+        end
+            ##
+        # Realiza el calculo del porcentaje de lipidos que tiene
+        def porlipidos()
+            lipidos = @alimentos.collect { |x| x.lipidos}
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...lipidos.size() do
+                lipidos[i]=lipidos[i]*cantidades[i]*0.01
+            end
+            ((lipidos.sum*9/@kcal)*100).round(2)
+        end
+        ##
+        # Realiza el calculo del porcentaje de carbohidratos que tiene
+        def porcarbohidratos()
+            carbohidratos = @alimentos.collect{ |x| x.carbohidratos }
+            cantidades = @cantidades.collect{|x| x}
+            for i in 0...carbohidratos.size() do
+                carbohidratos[i]=carbohidratos[i]*cantidades[i]*0.01
+            end
+            ((carbohidratos.sum*4/@kcal)*100).round(2)
+        end
+        ##
+        # Serializa el plato
+        def to_s()
+            "#{nombre}: #{alimentos.collect{|x| x.nombre}.join(",")} #{@kcal}kcal"
+        end
+        ##
+        # Permite comparar entre distintos platos según las kcal
+        def <=>(other)
+            @kcal<=>other.kcal
+        end
+    end
+end