=begin
This example show definition of a number of classes within the
same module ( a module is rather like a class, but you don't
construct object in it ) and the extra layer means you have another
. or :: in the naming, and you create in effect a separate namespace.
This is exactly what you'll want to do if you're sharing a whole set
of classes between applications, to avoid cluttering the application
namespace.

You'll also find in this example methods for comparing two objects
and for comparing a whole array of objects. The comparator for two
object will be an object method, and will return EITHER true/false or
one of the two objects. The comparator for the whole array of objects
will be a static (or class) method, and will return an object.

This example also shows inheritance (and how you call the base class
method of the same name as the method you're in with super). It shows
how attributes are overridden as necessary by methods - how the whole
lot work well together.

There's also an example of a singleton method - a method that's unique
to one specific object - which is defined in the test code. Such a
method can't actually be created until after the creation of the object.
=end

module Humphrey
class Food
attr_reader :itisa
def initialize(what,weight,cals)
        @itisa = what
        @weight = weight
        @calories = cals
        end
def getcalories()
        val = @calories * @weight /
                        100.0
        return "%7.2f" % val
        end
def < (second)
        return self.getcalories < second.getcalories
        end
def lessthan (second)
        return (self.getcalories < second.getcalories ? self : second)
        end
def self.least (these)
        so_far = these[0]
        (1...(these.length)).each do |tryme|
                so_far = these[tryme] if these[tryme] < so_far
        end
        return so_far
        end
end

class Eat < Food
attr_reader :dressed
@@yums = 0
def initialize(what,weight,cals,dressed = "no")
        @dressed = dressed
        super(what,weight,cals)
        @@yums += 1
        end
        end
class Drink < Food
        def itisa
                v = super()
                return "glass of #{v}"
        end
        def dressed
                return "No way"
        end
        def to_s
                return "DRINKIE!"
                end
end
end

# Here is our test code
bacon = Humphrey::Eat.new("Bacon Sarnie",75,200,"yes")
pear = Humphrey::Eat.new("Comice Pear",47,40,"no")
om = Humphrey::Drink.new("Orange Milk",250,70)
lunch = [bacon, pear, om]
lunch.push(Humphrey::Drink.new("water",1000,0.5))
lunch.push(Humphrey::Drink.new("Brandy",25,100))

def om.itisa
        return "disGUSTing"
        end

lunch.each do |current|
        cals = current.getcalories
        wot = current.itisa
        puts "This #{wot} has #{cals} calories"
        puts "#{current.dressed}"
        end

if pear < bacon
        puts "#{bacon.itisa}"
else
        puts "#{pear.itisa}"
end

better = pear.lessthan(bacon)
puts "#{better.itisa}"

best = Humphrey::Food::least(lunch)
puts "#{best.itisa}"

puts om
p om

__END__

Dorothy-2:d3 grahamellis$ ruby multifood.rb
This Bacon Sarnie has 150.00 calories
yes
This Comice Pear has 18.80 calories
no
This disGUSTing has 175.00 calories
No way
This glass of water has 5.00 calories
No way
This glass of Brandy has 25.00 calories
No way
Bacon Sarnie
Comice Pear
glass of water
DRINKIE!
#<Humphrey::Drink:0x25404 @calories=70, @weight=250, @itisa="Orange Milk">
Dorothy-2:d3 grahamellis$