---2138652406-851401618-9360307907308
Content-Type: TEXT/plain; charset=us-ascii

On 30 Aug, Minero Aoki wrote:
> Hi,
> 
>   In mail "[ruby-talk:00762] Re: RD with multi charset"
>     Clemens Hintze <c.hintze / gmx.net> wrote:
> 

[...]

> 
> 
> A writer can write his code and document in a single/multi file(s).
> And a reader will receive one code file (with English document),
> and language specific document files. You can use "rdtool" 
> (or other tools) for all these files directy.
> 
> My aim is "document swapping". For example, a reader receives
> these files:
> 

[Example and explanaition deleted...]

[...]

> Minero Aoki

Thanks for the nice explanation. If I have understand right what you
have said, I think this would be a good idea!

Below I have attached a tool, which I call `rdswap.rb'. Can you please
check out, if it does what you want? If yes, perhaps we could beg Toshi
to have a look to it, and add it into his `rdtool' distribution if he
like it too. :-)

\cle

---2138652406-851401618-9360307907308
Content-Type: APPLICATION/octet-stream
Content-Description: rdswap.rb

#!/bin/env ruby -s
#######
# rdswap.rb (c) C.Hintze <c.hintze / gmx.net> 30.08.1999
#######


require "ostruct";

if ARGV.size < 2 and not ($h or $help)
    print "Wrong # of paramter! Use `-h' for help.\n";
    exit 1;
elsif $h or $help
    print eval('"'+DATA.read+'"');
    exit 0;
end   

srcfile  RGV.select{|fn| fn /\.rb$/o};
case srcfile.size
when 0
    $stderr.print "Warning: No `.rb' file given! Take first file as source.\n";
    srcfile  RGV[0];
when 1
    srcfile  rcfile[0];
else
    print "Sorry! Only one source file (`.rb') allowed!\n";
    exit(1);
end

docs  };
srcs  };

rddoc, rddocs  il, [];
source, sources  ], [[]];

while gets
    lang  1 if File::basename(String($<)) /^.*?([^.]+)$/o;
    if /^in/o .. /^萲/o
        title  2 if /^本gin(\s+(.*))?$/o;
        unless rddoc.nil?
            unless /^萲/o
                rddoc.lines << $_;
            else
                rddocs << rddoc;
            	sources << [];
                rddoc  il;
            	title  il;
            end
        else               # New RD block found! Instantiate data container.
            rddoc  penStruct.new
            rddoc.kind, rddoc.lines  itle, [];
        end
    else                   # It is not a RD block means, it is a source line!
        sources[-1] << $_;
    end
    if $<.eof?             # One file finished. Remember data and proceed.
        docs[lang]  ddocs;
        srcs[lang]  ources;
        rddoc, rddocs  il, [];
        source, sources  ], [[]];
    end
end

langs  ocs.keys;
langs.delete("rb");        # `rb' is not a language but the script!
source  rcs["rb"];       # Assign it for preventing later look-ups
srcdoc  ocs["rb"];
sourcesize  ource.size;  # Do not recalculate size again and again.
srcdocsize  rcdoc.size;

for lang in langs
    docblk  ocs[lang];
	max  sourcesize, srcdocsize, docblk.size].max;
    filename  ile.join(srcfile+"."+lang);
    open(filename, "w+") do |fd|
        j  ;
        for i in 0...max   # Goto every block; be it source or RD.
            fd.print source[i].join unless source[i].nil? || source[i].empty?;
            sblk, dblk  rcdoc[i], docblk[j];
            blk  dblk and (dblk.kind sblk.kind)) ? dblk : sblk;
			next unless blk;
            j +  if blk dblk;
            fd.print "本gin #{blk && blk.kind}\n", blk.lines.join, "萲\n";
        end
    end
    print "File `#{filename}' created.\n" if $v;
end

exit(0);

__END__

Purpose:
   This tool is written to support you to write multi-language documents
   using the Ruby-Document-Format (RD).

   The idea for such a tool was originated by
   
   		Minero Aoki <aamine / dp.u-netsurf.ne.jp>,
		
   how has thought about, how to make life easier for developers who have to
   write and maintain scripts in more than one language.

   You have to specify at least two filenames on the command line. One
   containing the Ruby script, the second containing a translated RD. If the
   script does *not* end with `.rb', it has to be the first filename mentioned
   on the command line! In opposition, all files containing translations *must
   not* ending with `.rb'! They should use a extension that describes the
   language. So that would give us the following picture:

      - sample.rb : Script contains the original documentation.
      - sample.jp : Documentation written in Japanese.
      - sample.de : Translation to German.

   The tool doesn't care about the language extensions. You can name them as
   you like! So the file containing the Japanese translation above, could also
   be names e.g. `sample.japan' or even `japantranslation.japan'.

   For every translation file, a new file will be created. The name is build
   from the script filename plus the language extension. So regarding the
   example above, following files would be created:

      - sample.rb.jp
      - sample.rb.de

   or, given the alternative translation filename as mentioned above...

      - sample.rb.japan

How does it work?
   The contents of all files will be split into source and RD blocks. The
   source of the translation files, will be discarded! Every RD block may
   be of a certain type. The type will be taken from the contents directly
   following the `本gin' on the same line. If there is only a lonely `本gin'
   on a line by itself, the type of the block is `nil'. That means in

        :
        本gin
         bla bla
        萲
        :
        本gin whatever or not
         blub blub
        萲
        :
   
   the first block would be of type `nil' and the second one of type `whatever
   or not'.
   
   Block types are important for the translation. If a source will be
   generated from a script and a translation file, only these blocks are taken
   from the translation files, that comes in the right sequence *and* contains
   the same type as the block in the script! For example:

        # File sample.rb
        :
        本gin gnark
         Some comment
        萲
        :
        本gin
         block 2
        萲
        :
        本gin
         block 3
        萲
        :

        # File sample.de
        :
        本gin
         Block zwei
        萲
        :
        本gin
         Block drei
        萲
        :

   Here, the first block of `sample.rb' will *not* be translated, as there is
   no translation block with that type in sample.de! So the first block would
   be inserted as-it-is into the translated script. The blocks afterwards,
   however, are translated as the block type does match (it is `nil' there).

   Attention: In a translation file, a second block will only be used, if
              a first one was already used (matched). A third block will
              only be used, if a second one was used already!

   That means, if the first block of `sample.de' would be of type e.g. `Never
   match', then no block would ever be taken to replace anyone of `sample.rb'.
   
Syntax:
   #{File::basename $0} [-h|-v] <filename>...

Whereby:
   -h  shows this help text.
   -v  shows some more text during processing.
   <filename>  Means a file, that contains RD and/or Ruby code.

Examples:
   #{File::basename $0} -v sample.rb sample.ja sample.de
   #{File::basename $0} -v sample.ja sample.rb sample.de
   #{File::basename $0} -v sample.ja sample.de sample.rb
   #{File::basename $0} -v sample.??

Author:
   Clemens Hintze <c.hintze / gmx.net>.

---2138652406-851401618-9360307907308--