I really don't think that the podcast's discussion of "components" is directly in the context of the composite pattern. They are talking about component-based software engineering. I suppose this is one of the pitfalls of the ambiguity of software development terminology.
But, putting that aside to discuss the composite pattern, there's a nice explanation here, in case you haven't read it.
Basically, in the composite pattern, a Component class is simply a class that provides some abstract functionality. In most real-world use cases, it's a class with an interface to output data, like a post or a message. In ruby, I'll implement a
@message = ''
In the composite pattern, a Leaf is a single entity, that generally displays just one unit of information. In our example, a Single message will simply output the string that it is instantiated with:
class Single < Message
@message = message if message.is_a?(String)
In the composite pattern, a Composite is an object that can contain other components, whether those components are themselves Composite or simply single Leaves. For our example, I'll create a Multiple message class:
class Multiple < Message
@message = 
@message.each do |message|
def add (message)
message = Single.new(message) if message.is_a?(String)
@message << message if message.is_a?(Message)
The end result is that Multiple message objects can contain Single messages as well as nested Multiple messages
m1 = Multiple.new
m2 = Multiple.new
This code will output:
In metaphor, I suppose a Component could be like an executive in a business. Any given executive may work alone, or be the head of a division or department. But, when you go around and ask how much money each executive is going to need for the upcoming fiscal year, you don't care which one they are. If they work alone, they will simply tell you what their salary is/should be. If they are the head of a division, they will add on the money needed by all of the employees working under them. Those employees may or may not also be the heads of sub-devisions, in which case the same process would happen recursively.
Hope that helps!