rfil 0.2

data/examples/plinfo

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+#--
+# Last Change: Tue May 16 18:14:38 2006
+#++
+=begin rdoc
+== plinfo -- output information about a pl file.
+
+  Usage: plinfo [options] tfmfile.pl [file...]
+      -e, --encoding enc               set the encoding for the file
+      -l, --list-chars                 list all available characters
+      -h, --help                       Show this help
+  
+
+---
+Author:: Patrick Gundlach <patrick@gundla.ch>
+License::  Copyright (c) 2005 Patrick Gundlach.
+           Released under the terms of the GNU General Public License
+=end
+
+
+# :enddoc:
+
+require 'optparse'
+require 'ostruct'
+
+require 'tex/tfm'
+require 'tex/kpathsea'
+require 'tex/enc'
+         
+include TeX
+
+kpse=Kpathsea.new
+
+@options=OpenStruct.new
+
+ARGV.options { |opt|
+  opt.banner = "Usage: #{File.basename($0)} [options] tfmfile.pl [file...]"
+  opt.on("--encoding enc", "-e", "set the encoding for the file") { |e|
+    kpse.open_file(e,"enc") { |f|
+      @options.encoding = ENC.new(f)
+    }
+  }
+  opt.on("--list-chars", "-l", "list all available characters") {
+    @options.listchars=true }
+  opt.on("--help", "-h", "Show this help") { puts opt; exit 0 }
+  opt.separator  ""
+  opt.parse!
+}
+
+if ARGV.size < 1
+  puts "#{File.basename($0)}: Need at least one file argument."
+  puts "Try `#{File.basename($0)} --help' for more information."
+  exit 0
+end
+
+
+def dump_maininfo(filename)
+  puts "General font information:"
+  puts "========================="
+  print "filename=#{File.basename(filename)} "
+  # puts @isvpl ? "(vpl)" : "(pl)"
+  puts "Family: #{@tfm.fontfamily}"
+  puts "Designsize: #{@tfm.designsize}"
+  puts "Codingscheme: #{@tfm.codingscheme}"
+  puts "Fontdimen:"
+  paramname=%w( SLANT SPACE STRETCH SHRINK XHEIGHT QUAD EXTRASPACE )
+    if @tfm.codingscheme=="TeX math symbols"
+      paramname += %w(NUM1 NUM2 NUM3 DENOM1 DENOM2 SUP1 SUP2 SUP3
+                      SUB1 SUB2 SUPDROP)
+    elsif @tfm.codingscheme=="TeX math extension"
+      paramname += %w(DEFAULT_RULE_THICKNESS BIG_OP_SPACING1
+      BIG_OP_SPACING2 BIG_OP_SPACING3 BIG_OP_SPACING4 BIG_OP_SPACING5) 
+    end
+
+  (1..@tfm.params.size-1).each {|i|
+    puts "  #{paramname[i-1]} = #{@tfm.params[i]}"
+  }
+end
+
+def dump_charsinfo
+  stdformat="%9s|"
+  count=0
+  0.upto(255)  { |i|
+    if c=@tfm.chars[i]
+      if count % 32 == 0
+        puts "\n slot|   width |  height |   depth |      ic |lig/kern?|   extra |  char"
+        puts "-----|---------|---------|---------|---------|---------|---------|-------"
+      end
+
+      has_krn= c[:lig_kern] ?  "yes" : ""
+      extra = ""
+      char = @options.encoding ? @options.encoding[i] : ""
+      puts sprintf("%5s|"+stdformat*6+" %s", "#{i}","#{c[:charwd]}","#{c[:charht]}","#{c[:chardp]}","#{c[:charic]}", has_krn,"",char)
+      count += 1
+      
+    end
+
+  }
+end
+
+ARGV.each { |plfilename|
+  @tfm=TFM.new()
+  @tfm.read_pl(plfilename)
+  dump_maininfo(plfilename)
+  if @options.listchars
+    dump_charsinfo
+  end
+}

data/examples/rfii

@@ -0,0 +1,257 @@
+#!/usr/bin/env ruby
+
+# :enddoc:
+
+require 'pp'
+require 'ostruct'
+require 'fileutils'
+
+
+require 'rfil/fontcollection'
+require 'tex/kpathsea'
+
+$:.unshift File.dirname($0)
+require 'rfii.tab'
+
+
+class RFII # :nodoc:
+  include RFIL
+  include TeX
+
+  def initialize
+    @instructions=[]
+    @known_encodings=Hash.new
+    @fontset=nil
+    @kpse=Kpathsea.new
+    @known_outputfiles=[:vf,:sty,:tfm,:typescript,:fd,:map]
+    @fontfiles_copied=nil
+    @vendor=nil
+    @texencodings=[]
+    @psencoding=[]
+    @fontroot=File.expand_path(Dir.pwd)
+    @options=OpenStruct.new
+    @options.verbose=false
+    @options.dryrun=false
+    @options.tds=true
+    @fc=nil
+  end
+  
+  def parse_file(filename)
+    f=File.open(filename)
+    @s=StringScanner.new(f.read)
+    f.close
+    @mode=:normal
+    @line=1
+    yyparse(self,:scan)
+  end
+  
+  def on_error(error_token_id,error_value,value_stack)
+    # puts "error"
+    error=token_to_str(error_token_id)
+    p error_value,value_stack
+    puts "parse error near line #@line, exiting, next string: '#{error_value}#{@s.rest[0..20]}...'"
+    exit 1
+    # the default action would be:
+    # raise ParseError
+  end
+  
+  def ensure_encoding(enc)
+    unless @known_encodings.has_key?(enc)
+      puts "Unknown encoding #{enc} in line #{@line}"
+      exit 1
+    end
+  end
+
+  def get_encodings(symbols)
+    symbols.collect { |encoding|
+      ensure_encoding(encoding)
+      @known_encodings[encoding]
+    }
+  end
+  def get_encoding(symbol)
+    return :none if symbol==:none or symbol==:same_as_texencoding
+    ensure_encoding(symbol)
+    @known_encodings[symbol]
+  end
+
+  def get_fonts(ident)
+    towrite=[]
+    case ident
+    when [:all],nil
+      towrite=@fontset.keys
+    else
+      towrite=ident
+    end
+    fontlist=[]
+    towrite.each{ |font|
+      if @fontset.has_key?(font)
+        fontlist << @fontset[font]
+      else
+        puts "Font for #{ident} in line #{@line} unknown, ignoring"
+      end
+    }
+    fontlist
+  end
+  def run_instructions
+    @instructions.each { |line,i|
+      @line=line
+      instr,*rest=i
+      case instr
+      when :useencoding
+        # this should be in parser:
+        if rest[1]==:none or rest[1]==:same_as_texencoding
+          puts "invalid encoding name"
+          exit 1
+        end
+        @kpse.open_file(rest[0],"enc") { |encfile|
+          @known_encodings[rest[1]]=ENC.new(encfile)
+        }
+      when :psencoding
+        @psencoding=get_encoding(rest[0])
+      when :texencoding
+        @texencodings=get_encodings(rest[0])
+      when :fontroot
+        @fontroot=File.expand_path(rest[0])
+        unless File.exists?(@fontroot) and File.directory?(@fontroot)
+          puts "fontroot (#{@fontroot})is not a valid directory"
+          exit 1
+        end
+      when :fontsource
+        @fontsource=File.expand_path(rest[0])
+        unless File.exists?(@fontsource) and File.directory?(@fontsource)
+          puts "fontsource (#{@fontsource})is not a valid directory"
+          exit 1
+        end
+      when :newfont
+        @fontset={}
+        @fontfiles_copied={}
+        @fc=RFI::FontCollection.new
+        @fc.options[:dryrun]=@options.dryrun
+        @fc.options[:verbose]=@options.verbose
+        @fc.vendor=@vendor
+        @fc.name=rest[0]
+        @fc.set_dirs({:base=>@fontroot, :tds=>@options.tds})
+        @fc.mapenc=@psencoding
+        @fc.texenc=@texencodings
+        @fc.style=rest[1]
+      when :useafm
+        fontfilename=rest[0]
+        ident=rest[1]
+        srcpath=File.join(@fontsource,fontfilename)
+        unless @fontfiles_copied.has_key?(fontfilename) and @options.copyfonts
+          @fontfiles_copied[fontfilename]=true # dummy value, used as Set
+          
+          if @options.verbose
+            puts "copy #{srcpath} to #{@fc.dirs[:afm]}"
+          end
+          unless @options.dryrun
+            @fc.ensure_dir(@fc.dirs[:afm])
+            FileUtils.cp(srcpath,@fc.dirs[:afm])
+          end
+          if @options.verbose
+            puts "copy #{srcpath.chomp(".afm")}.pfb to #{@fc.dirs[:type1]}"
+          end
+          unless @options.dryrun
+            @fc.ensure_dir(@fc.dirs[:type1])
+            FileUtils.cp(srcpath.chomp(".afm")+".pfb",@fc.dirs[:type1])
+          end
+        end
+        f=RFI::Font.new(@fc)
+        i=f.load_variant(File.join(@fontsource,fontfilename))
+        @fontset[ident]=f
+        case ident
+        when :italic
+          f.variant=:italic
+        when :slanted
+          f.variant=:slanted
+        when :bold
+          f.weight=:bold
+        when :bolditalic
+          f.variant=:italic
+          f.weight=:bold
+        when :boldslanted
+          f.variant=:slanted
+          f.weight=:bold
+        when :smallcaps
+          f.variant=:smallcaps
+        end
+      when :write
+        # p rest
+        texencodings =  if rest[2]
+                          get_encodings(rest[2])
+                        else
+                          @texencodings
+                        end
+        
+        psencoding  = rest[3] ? get_encoding(rest[3]) : @psencoding
+        rest[0].each { |filetype|
+          case filetype
+          when :vf
+            get_fonts(rest[1]).each { |font|
+              font.texenc=texencodings
+              font.mapenc=psencoding
+              font.write_files({:mapfile=>false})
+            }
+          when :map
+            m = get_fonts(rest[1]).collect { |font|
+              font.texenc=texencodings
+              font.mapenc=psencoding
+              font.maplines
+            }
+            mapdir=@fc.get_dir(:map); @fc.ensure_dir(mapdir)
+            mapfilename=File.join(mapdir,@fc.name+".map")
+            if @options.verbose
+              puts "writing mapfile to #{mapfilename}"
+            end
+            unless @options.dryrun
+              File.open(mapfilename, "w") {|file|
+                file.puts m
+              }
+            end
+          when :fd
+            @fc.run_temps(:latex)
+          when :typescript
+            @fc.run_temps(:context)
+          else
+            puts "unknown filetype: #{filetype}, ignoring"
+          end
+        }
+      when :vendor
+        @vendor=rest[0]
+        if @fc and @fc.respond_to?(:vendor=)
+          @fc.vendor=@vendor
+        end
+      when :set
+        kw,values=rest
+        case kw
+        when :verbose,:dryrun,:tds,:copyfonts
+          if [:true,:false].member?(values)
+            @options.send(kw.to_s+"=",values==:true)
+          else
+            puts "Warning: unkown value for '#{kw}' in line #{@line}, must be one of 'true' or 'false'"
+          end
+        end
+      when :apply
+        instr=rest[0]
+        case instr
+        when :slant
+          font=rest[1]
+          # p @fontset.has_key?(font)
+          @fontset[font].slant=0.167
+        else
+          puts "Unknown instruction (#{instr}) for apply in line #{@line}. Exiting."
+        end
+      else
+        puts "Unknown instruction (#{instr}) in line #{@line}. Exiting."
+        exit 1
+      end
+    }
+    # p @psencoding
+    # p @texencodings
+    # pp @fc
+  end
+end
+
+parser = RFII.new
+parser.parse_file("test/inputfile")
+parser.run_instructions

data/examples/rfont

@@ -0,0 +1,188 @@
+#!/usr/bin/env ruby
+#--
+# Last Change: Tue May 23 20:32:20 2006
+#++
+=begin rdoc
+= rfont -- An example font installer
+
+rfont uses the RFI Library for installing a family of fonts.
+
+== Command line parameters
+Usage: rfont [options] vendor/fontname  FILE1 FILE2 ...
+    -c, --copy-fonts                 Also copy the font outlines
+    -d, --directory DIR              Set base directory to DIR
+        --dry-run                    dry run, don't create any files
+    -m, --list-plugin                list available macro support methods
+    -p ENCFILE                       read/download ENCFILE for the PostScript encoding
+    -s, --style STYLE                Style of the font, eg. sans, roman, typewriter
+        --tds                        Put files in a TDS compliant directory hierarchy
+    -t ENCFILE                       read ENCFILE for the encoding of the vf file
+                                     multiple encodings can be given (seperated by ',')
+    -T ENCFILE                       equivalent to -p ENCFILE -t ENCFILE
+    -u, --use-plugin PLUGIN          use plugin files PLUGIN, multiple files seperated by ','
+    -v, --no-vf                      Do not create virtual fonts for reencoding
+        --verbose                    Print more then needed on stdout
+        --help                       print this message and exit.
+        --version                    print version number and exit.
+
+== Example usage
+This is the command line I used to install the Bitstream variant of the font 'Syntax' (from the Corel Draw CD)
+
+  ./rfont bitstream/syntax ../corel/hum531*afm -t ec,ts1 -p 8r -d ~/rfitexmf/ -u latex -s sans --verbose  --tds  -c
+
+It works, but the <tt>.fd</tt>-file is not perfect yet.
+---
+Author:: Patrick Gundlach <patrick@gundla.ch>
+License::  Copyright (c) 2005 Patrick Gundlach.
+           Released under the terms of the GNU General Public License
+
+=end
+
+# :enddoc:
+
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+
+require 'rfil/fontcollection'
+
+include RFIL
+
+options=OpenStruct.new
+optionswritevf=true
+fc=RFI::FontCollection.new
+
+ret= ARGV.options { |opts|
+  opts.banner = "Usage: #{File.basename($0)} [options] vendor/fontname  FILE1 FILE2 ..."
+  opts.on("-c", "--copy-fonts", "Also copy the font outlines") {
+    options.copyfonts=true
+  }
+ 
+  opts.on("-d DIR", "--directory", "Set base directory to DIR") { |d|
+    fc.set_dirs(d)
+  }
+  opts.on("--dry-run", "dry run, don't create any files") {
+    fc.options[:dryrun]=true
+    options.dryrun=true
+  }
+  opts.on("-m", "--list-plugin", "list available plugins") {
+    puts "The following plugins are known:"
+    puts fc.plugins
+    exit 0;
+  }
+  opts.on("-p ENCFILE", String,
+          "read/download ENCFILE for the PostScript encoding") {|e|
+    fc.mapenc =  e
+  }
+  opts.on("-s STYLE", "--style", String, "Style of the font, eg. sans, roman, typewriter") { |s|
+    fc.style=s.to_sym
+  }
+  opts.on("--tds", "Put files in a TDS compliant directory hierarchy") {
+    options.tds=true
+  }
+  opts.on("-t ENCFILE",Array, "read ENCFILE for the encoding of the vf file",
+          "multiple encodings can be given (seperated by ',')") {|e|
+    fc.texenc = e
+  }
+  opts.on("-T ENCFILE",String,"equivalent to -p ENCFILE -t ENCFILE") {|e|
+    fc.mapenc = e
+    fc.texenc = e
+  }
+  opts.on("-u PLUGIN","--use-plugin",Array, "use plugin PLUGIN, multiple files seperated by ','") { |m|
+    options.plugin=m
+  }
+  opts.on("-v", "--no-vf", "Do not create virtual fonts for reencoding") {
+    fc.write_vf=false
+  }
+  opts.on("--verbose","Print more then needed on stdout") {
+    options.verbose=true
+    fc.options[:verbose]=true
+  }
+  opts.on_tail("--help","print this message and exit.") { puts opts; exit 0 }
+  opts.on_tail("--version","print version number and exit.") {
+    puts "#{File.basename($0)}: Version 0.1"
+    exit 0
+  }
+  opts.parse!
+}
+unless ret
+  puts "See --help for usage information"
+  exit(-1) 
+end
+
+
+vendor_fontname=ARGV.shift
+
+if vendor_fontname
+  options.vendor,options.fontname=vendor_fontname.split('/')
+end
+if options.vendor==nil or options.fontname==nil
+  puts "You must name vendor and fontname this way: vendor/fontname"
+  puts "See --help for usage information"
+  exit(-1)
+end
+
+
+
+fc.name=options.fontname
+fc.vendor=options.vendor
+
+fc.set_dirs(:tds=>true) if options.tds
+
+fonts=[]
+maplines=""
+
+if ARGV.empty?
+  puts "No fonts given.\nSee --help for usage information"
+  exit -1
+end
+fontoutlinedir=File.dirname(ARGV[0])
+
+ARGV.each { |fontname|
+  # puts "reading font #{File.basename(fontname)}"
+  f=RFI::Font.new(fc)
+  f.load_variant(fontname)
+  fonts.push f
+}
+
+fc.fonts.each { |font|
+  puts "Processing font #{font.defaultfm.fontname}"
+  font.guess_weight_variant
+  font.apply_ligkern_instructions(RFI::STDLIGKERN)
+  font.write_files(:dryrun=>options.dryrun==true,
+                   :verbose=>false, :mapfile=>false
+                   )
+  maplines << font.maplines.to_s
+}
+
+
+if options.copyfonts
+  fc.fonts.each { |font|
+    font.find_used_fonts.each {|varnumber|
+      fontmetric=font.variants[varnumber]
+      destdir=font.get_dir(fontmetric.outlinetype)
+      sourcefile=File.join(fontoutlinedir,fontmetric.fontfilename)
+      destfile=File.join(destdir,fontmetric.fontfilename)
+      puts "Copying #{sourcefile} to #{destfile}" if options.verbose
+      fc.ensure_dir(destdir)
+      unless options.dryrun
+        FileUtils.cp(sourcefile,destfile)
+      end
+    }
+  }
+end
+
+mapdir=fc.get_dir(:map)
+mapfile=File.join(mapdir,options.fontname)
+puts "Writing mapfile #{mapfile}" if options.verbose
+unless fc.options[:dryrun]
+  fc.ensure_dir(mapdir)
+  File.open(mapfile + ".map", "w") { |f|
+    f << maplines
+  }
+end
+
+if options.plugin
+  options.plugin.each { |m|  fc.run_plugin(m.to_sym)   }
+end
+