cocoon-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Carsten Ziegeler" <cziege...@s-und-n.de>
Subject [RT]: Dynamic variables in the Sitemap / Input Modules revisited
Date Thu, 09 Jan 2003 08:28:02 GMT
Hi,

I think today is a good day to....dada...continue our 
famous InputModules discussion. hurray.

Ok, I think we currently have a deadlock. Some of us say a) and not b)
and the others say b) and not a). Who is right? I don't know. 
Would a vote help? No, definitly not.
So instead we should try to reach consensus (and I think this will not 
be too hard).

I have the perception that we did one thing wrong: we started
by looking at the implementation and from there turned over to
the concept. And this is not they way it should be. We should first
discuss the concept and can then later on thing about how
to implement it or what existing implementations we can use. 

So please do not use any java code, class names etc in this RT.

In addition I will try to avoid all the names that already have
a meaning, like InputModules, Properties etc.

So, on what do we agree?

First, of course, we want a dynamic substitution mechanism in the
sitemap that we can use nearly everywhere. This mechanism uses
different objects to resolve the dynamic values. An object is
represented by a distinct name and gets an identifier for the
actual value. We agree, that the syntax for using this is:

     {object_identifier:key}

An example is {request-param:myparameter}.

The key passed to the object is custom to the object, which means
that it can be a simple name or an xpath expression or whatever as
long as it is representable as a string/text.

We all agree that the objects that provide those values should
be declared in the sitemap as components (I use the name objects
here to avoid any collision, so let's not discuss this):

<map:objects>
   <map:object name="request-param" ..../>
</map:objects>

I think, up to this point we all agree, right?

Now, let's come to the missing part, chaining!

I think we have currently two approaches:
a) Chaining is done by special objects, so you have something like
   this (let's not discuss the "first"/"second" syntax):

  <map:objects>
   <map:object name="request-param" ..../>
   <map:object name="session-attr" ..../>
   <map:object name="my_chain ....>
     <first>request-param</first>
     <second>session-attr</second>
     ...
   </map:object>
  </map:objects>
  And I can simply use {request-param:myname} and {my_chain:skin}

b) Chainers (?) are special components:

  <map:objects>
   <map:object name="request-param" ..../>
   <map:object name="session-attr" ..../>
  </map:objects>
  <map:object-chainers>
   <map:object-chainer name="my_chain ....>
     <first>request-param</first>
     <second>session-attr</second>
     ...
   </map:object>  
  </map:object-chainers>

  And I can simply use {request-param:myname} and {my_chain:skin}

Personally I would opt for a) because b) adds another component type
to the sitemap that is not really needed and it might be confusing
that {request-param:myname} is handled by an object component and
{my_chain:skin} by an object-chainer.

Is everything correctly reproduced? Is anything missing for the concept?

PS: you see that I really try to avoid our long and great naming
    discussion - when we have the concept we will find proper names
    for it, believe me.... ;)

Carsten 

Carsten Ziegeler 
Open Source Group, S&N AG


---------------------------------------------------------------------
To unsubscribe, e-mail: cocoon-dev-unsubscribe@xml.apache.org
For additional commands, email: cocoon-dev-help@xml.apache.org


Mime
View raw message