rfil 0.2

data/lib/rfil/rfi_plugin_context.rb

@@ -0,0 +1,90 @@
+=begin rdoc
+Plugin for RFIL to create a typescript usable for ConTeXt.
+=end
+
+# :enddoc:
+
+class TypescriptWriterConTeXt < RFIL::RFI::Plugin
+  
+  def initialize(fontcollection)
+    @fc=fontcollection
+    super(:context,:typescript)
+  end
+
+  STOPTYPESCRIPT="\\stoptypescript\n\n"
+  
+  def run_plugin
+    ret=[]
+    str=""
+    puts "running context plugin" if @fc.options[:verbose]
+    @fc.texenc.each { |e|
+      str << typescript(e)
+      str << "\n"
+    }
+    h={}
+    h[:type]=:typescript
+    h[:filename],h[:contents]=["type-#{@fc.name}.tex",str]
+    ret.push(h)
+    ret
+  end
+
+  # Returns hash: Style, font
+  def find_fonts
+    ret={}
+    @fc.fonts.each { |font|
+      ret[""]=font if font.variant==:regular and font.weight==:regular 
+#      ret[""]=font if font.variant==:regular and font.weight==:regular and font.style!=:sans
+      ret["Bold"]=font if font.variant==:regular and font.weight==:bold
+      ret["Italic"]=font if font.variant==:italic and font.weight==:regular
+      ret["Caps"]=font if font.variant==:smallcaps and font.weight==:regular
+    }
+    ret
+  end
+  def typescript(e)
+    contextenc=case e.encname
+               when "ECEncoding"
+                 "ec"
+               when "TS1Encoding"
+                 "ts1"
+               when "T1Encoding"
+                 "tex256"
+               when "TeXBase1Encoding"
+                 "8r"
+               else
+                 raise "unknown context encoding: #{e.encname}"
+               end
+    # i know that this is crap, it's just a start
+    contextstyle=case @fc.style
+                 when :sans
+                   "Sans"
+                 when :roman, :serif
+                   "Serif"
+                 when :typewriter
+                   "Typewriter"
+                 else
+                   raise "unknown style found: #{@fc.style}"
+                 end
+    tmp = ""
+    fontname=@fc.name
+    tmp << "\\starttypescript[#{@fc.style}][#{fontname}][name]\n"
+    find_fonts.sort{ |a,b| a[0] <=> b[0]}.each { |style,font|
+      tmp << "\\definefontsynonym [#{contextstyle}"
+      p style
+      tmp << "#{style}" if style.length > 0
+      tmp << "] [#{fontname}"
+      tmp << "-#{style}" if style.length > 0
+      tmp << "]\n"
+    }
+    tmp << STOPTYPESCRIPT
+
+    tmp << "\\starttypescript[#{@fc.style}][#{fontname}][#{contextenc}]\n"
+    find_fonts.sort{ |a,b| a[0] <=> b[0]}.each { |style,font|
+      tmp << "\\definefontsynonym [#{fontname}"
+      tmp << "-#{style}" if style.length > 0
+      tmp << "][#{font.tex_fontname(e)}]\n"
+    }
+    tmp << STOPTYPESCRIPT
+
+    return tmp
+  end
+end

data/lib/rfil/rfi_plugin_latex.rb

@@ -0,0 +1,95 @@
+=begin rdoc
+Plugin for RFIL to create a fontdefinition file (<tt>.fd</tt>) for LaTeX
+=end
+
+# :enddoc:
+
+class FDWriterLaTeX < RFIL::RFI::Plugin
+  
+  def initialize(fontcollection)
+    @fc=fontcollection
+    super(:latex,:sty)
+  end
+
+  def run_plugin
+    ret=[]
+    @fc.texenc.each { |e|
+      h={}
+      h[:type]=:fd
+      h[:filename],h[:contents]=latex_fd(e)
+      ret.push(h)
+    }
+    ret
+  end
+
+  
+  # example, should be an extra plugin
+  def latex_fd(e)
+    latexenc=case e.encname
+             when "ECEncoding","T1Encoding"
+               "T1"
+             when "TeXBase1Encoding"
+               "8r"
+             when "TS1Encoding"
+               "TS1"
+             when "OT2AdobeEncoding"
+               "OT2"
+             else
+               raise "unknown latex encoding: #{e.encname}"
+             end
+    filename="#{latexenc.downcase}#{@fc.name}.fd"
+
+    fd="\\ProvidesFile{#{filename}}
+\\DeclareFontFamily{#{latexenc}}{#{@fc.name}}{}
+"
+    weight=[:m,:b,:bx]
+    variant=[:n,:sc,:sl,:it]
+    for i in 0..11
+      w=weight[i/4]
+      v=variant[i % 4]
+      f=find_font(w,v)
+      if f
+        name = f.tex_fontname(e)
+      else
+        if i < 4
+          name = "ssub * #{@fc.name}/m/n"
+        else
+          name = "ssub * #{@fc.name}/#{weight[i/4 - 1]}/#{v}"
+        end
+      end
+        
+#     [[:m,:n],[:m,:sc],[:m,:sl],[:m,:it],
+#       [:b,:n],[:b,:sc],[:b,:sl],[:b,:it],
+#       [:bx,:n],[:bx,:sc],[:bx,:sl],[:bx,:it]].each{ |w,v|
+#       f=find_font(w,v)
+      
+#       name = f ? f.tex_fontname(e) : "<->ssub * #{@fc.name}/m/n"
+      fd << "\\DeclareFontShape{#{latexenc}}{#{@fc.name}}{#{w}}{#{v}}{
+      <->   #{name}
+}{}
+"
+    end
+  return [filename,fd]
+end
+  def find_font(w,v)
+    weight={}
+    variant={}
+    weight[:m]=:regular
+    weight[:b]=:bold
+    variant[:n]=:regular
+    variant[:it]=:italic
+    variant[:sl]=:slanted
+    variant[:sc]=:smallcaps
+
+    # w is one of :m, :b, :bx
+    # v is one of :n, :sc, :sl, :it
+    @fc.fonts.each { |font|
+      #p b[:weight]==weight[w]
+      if font.variant ==variant[v] and font.weight==weight[w]
+        return font
+      end
+    }
+    return nil
+  end
+  
+end

data/lib/rfil/version.rb

@@ -0,0 +1,3 @@
+RFIL_VERSION="0.2"
+COPYRIGHT="Copyright (c) 2006 Patrick Gundlach <patrick@gundla.ch>"
+HOMEPAGE="https://foundry.supelec.fr/projects/rfil"

data/lib/tex/enc.rb

@@ -0,0 +1,223 @@
+#--
+# enc.rb - read and parse TeX's encoding files
+# Last Change: Tue May 16 17:24:31 2006
+#++
+# See the class ENC for the api description.
+
+require 'strscan'
+require 'set'
+require 'forwardable'
+
+  module TeX
+
+    # = ENC -- Access encoding files
+    #
+    # == General information
+    #
+    # Read a TeX encoding vector (<tt>.enc</tt>-file) and associated
+    # ligkern instructions. The encoding slot are accessible via <em>[]</em>
+    # and <em>[]=</em>, just like an Array.
+    #
+    # == Example usage
+    #
+    # === Read an encoding file
+    #  filename = "/opt/tetex/3.0/texmf/fonts/enc/dvips/base/EC.enc"
+    #  File.open(filename) { |encfile|
+    #     enc=ENC.new(encfile)
+    #     enc.encname   # => "ECEncoding"
+    #     enc           # => ['grave','acute',...]
+    #     enc.filename  # => "EC.enc"
+    #     enc.ligkern_instructions  # => ["space l =: lslash","space L =: Lslash",... ]
+    #  }
+    # === Create an encoding
+    #  enc=ENC.new
+    #  enc.encname="Exampleenc"
+    #  enc[0]="grave"
+    #  # all undefined slots are ".notdef"
+    #  ....
+    #
+    #  # write encoding to <tt>new.enc</tt>
+    #  File.open("new.enc") do |f|
+    #     f << enc.to_s
+    #  end
+    # ---
+    # Remark: This interface is pretty much fixed.
+    #--
+    # dont't subclass Array directly, it might be a bad idea. See for
+    # example [ruby-talk:147327]
+    #++
+
+    class ENC # < DelegateClass(Array)
+      def self.documented_as_accessor(*args) # :nodoc:
+      end 
+
+      extend Forwardable
+      def_delegators(:@encvector, :size, :[],:each, :each_with_index)
+      
+      # _encname_ is the PostScript name of the encoding vector.
+      attr_accessor :encname
+
+      # ligkern_instructions is an array of strings (instructions) as
+      # found in the encoding file, such as:
+      # "quoteright quoteright =: quotedblright"
+      # "* {} space"
+      attr_accessor :ligkern_instructions
+
+      # Hash: key is glyph name, value is a Set of indexes. 
+      # Example: glyph_index['hyphen']=#<Set: {45, 127}> in
+      # <tt>ec.enc</tt>. Automatically updated when changing the encoding
+      # vector via <em>[]=</em>.
+      attr_reader :glyph_index
+
+      # Filename of the encoding vector. Used for creating mapfile
+      # entries. Always ends with ".enc" if read (unless it is unset).
+      documented_as_accessor :filename
+      
+      # Optional enc is either a File object or a string with the contents
+      # of a file. If set, the object is initialized with the given
+      # encoding vector.
+      def initialize (enc=nil)
+        @glyph_index={}
+        @ligkern_instructions=[]
+        # File, Tempfile, IO respond to read
+        if enc
+          @encvector=[]
+          string = enc.respond_to?(:read) ? enc.read : enc
+          if enc.respond_to?(:path)
+            self.filename= enc.path
+          end
+          parse(string)
+        else
+          @encvector=Array.new(256,".notdef")
+        end
+      end
+
+      def filename # :nodoc:
+        @filename
+      end
+      
+      def filename=(fn) # :nodoc:
+        @filename=File.basename(fn.chomp(".enc")+".enc")
+      end
+
+      # Return true if the encoding name and the encoding Array are the
+      # same. If _obj_ is an Array, only compare the Array elements.
+      def ==(obj)
+        return false if obj==nil
+        if obj.instance_of?(ENC)
+          return false unless @encname==obj.encname
+        end
+        
+        return false unless obj.respond_to?(:[])
+        0.upto(255) { |i|
+          return false if @encvector[i]!=obj[i]
+        }
+        true
+      end
+
+      # todo: document and test
+      def -(obj)
+        tmp=[]
+        for i in 0..255
+          tmp[i]=obj[i]
+        end
+        @encvector - tmp
+      end
+      
+      # also updates the glyph_index
+      def []=(i,obj) # :nodoc:
+        if obj==nil and @encvector[i] != nil
+          @glyph_index.delete(@encvector[i])
+          return obj
+        end
+        
+        @encvector[i]=obj
+        addtoindex(obj,i)
+        return obj
+      end
+      
+      # Return a string representation of the encoding that is compatible
+      # with dvips and alike.
+      def to_s
+        str = ""
+        @ligkern_instructions.each { |instr|
+          str << "% LIGKERN #{instr} ;\n"
+        }
+        str << "%\n"
+        str << "/#@encname [\n"
+        @encvector.each_with_index { |glyphname,i|
+          str << "% #{i}\n" if (i % 16 == 0)
+          str << " " unless (i % 8 == 0)
+          str << "/#{glyphname}"
+          str << "\n" if (i % 8 == 7)
+        }
+        str << "] def\n"
+        str
+      end
+      
+      #######
+      private
+      #######
+
+      # creates the glyph_index from the encvector. Use this method after
+      # you made changes to the encvector.
+      def update_glyph_index
+        @encvector.each_with_index { |name,i|
+          next if name==".notdef"
+          addtoindex(name,i)
+        }
+      end
+
+      # Adds position i to glyph_index for glyph _glyph_.
+      def addtoindex(glyph,i)
+        return if glyph==".notdef"
+        if @glyph_index[glyph]
+          @glyph_index[glyph].add i
+        else
+          @glyph_index[glyph]=Set.new().add(i)
+        end
+      end
+
+      # return the next postscript element (e.g. /name or [ )
+      def tok(s)
+        unless s.peek(1) == "/"
+          s.skip_until(/[^\/\[\]]+/) # not '/' '[' or ']'
+        end
+        s.scan(/(?:\/\.?\w+|\[|\])/)
+      end
+
+      # fill Array with contents of string. 
+      def parse(str)
+        count=0
+        s=StringScanner.new(str)
+        ligkern=""
+        while s.skip_until(/^%\s+LIGKERN\s+/)
+          ligkern  << s.scan_until(/$/)
+        end
+        ligkern.split(';').each  { |instruction|
+          @ligkern_instructions.push instruction.strip
+        }
+        s.string=(str.gsub(/%.*/,''))
+        t=tok(s)
+        @encname=t[1,t.length-1]
+        loop do
+          t = tok(s)
+          case t
+          when "["
+            # ignore
+          when "]"
+            unless @encvector.size == 256
+              raise "Unexpected size of encoding. It should contain 256 entries, but has #{@encvector.size} entries."
+            end
+            update_glyph_index
+            return
+          else
+            name = t[1,t.length-1]
+            @encvector.push(name)
+          end
+        end
+        # never reached
+        raise "Internal ENC error"
+      end
+    end #class Enc
+  end 

data/lib/tex/kpathsea.rb

@@ -0,0 +1,63 @@
+#--
+# kpathsea.rb - libkpathsea access for ruby
+# Last Change: Tue May 16 17:23:14 2006
+#++
+
+
+module TeX
+
+  # Find TeX related files with help of the 'kpsewhich' program.
+  class Kpathsea
+    # _progname_ defaults to the name of the main Ruby script.
+    # _progname_ is used to find program specific files as in
+    # <tt>TEXINPUT.progname</tt> in the <tt>texmf.cnf</tt>.
+    def initialize (progname=File.basename($0))
+      raise ArgumentError if progname.match(/('|")/)
+      @progname=progname
+    end
+
+    def reset_program_name(suffix)
+      @progname=suffix
+    end
+
+    # Return the complete path of the file _name_. _name_ must not
+    # contain single or double quotes.
+    def find_file(name,fmt="tex",mustexist=false)
+      raise ArgumentError if name.match(/('|")/)
+      raise ArgumentError if fmt.match(/('|")/)
+      runkpsewhich(name,fmt,mustexist)
+    end
+
+    # Return a File object. Raise Errno::ENOENT if file is not found. If
+    # block is given, a File object is passed into the block and the
+    # file gets closed when leaving the block. It behaves exactly as 
+    # the File.open method.
+    def open_file(name,fmt="tex")
+      loc=self.find_file(name,fmt)
+      raise Errno::ENOENT, "#{name}" unless loc
+      if block_given?
+        File.open(loc) { |file|
+          yield file
+        }
+      else
+        File.open(loc)
+      end
+    end
+
+    private
+
+    def runkpsewhich(name,fmt,mustexist)
+      fmt.untaint
+      name.untaint
+      @progname.untaint
+      # path or amok XXX
+      cmdline= "kpsewhich -progname=\"#{@progname}\" -format=\"#{fmt}\" #{name}"
+      # puts cmdline
+      lines = ""
+      IO.popen(cmdline) do |io|
+        lines = io.readlines
+      end
+      return $? == 0 ? lines.to_s.chomp.untaint : nil
+    end
+  end
+end