rfil 0.2

data/lib/rfil/font/metric.rb

@@ -0,0 +1,135 @@
+# font/metric.rb - superclass for different font metric formats
+# Last Change: Mi 24 Mai 2006 16:13:14 CEST
+
+require 'rfil/font/glyph'
+#require 'font/afm'
+#require 'font/truetype'
+
+module RFIL
+  module Font
+    # FontMetric is the superclass for font metrics. All information that
+    # is not specific to a certain kind of file format is accessible via
+    # this class.
+
+    class Metric
+      # to make Rdoc and Ruby happy: [ruby-talk:147778]
+      def self.documented_as_accessor(*args) # :nodoc:
+      end 
+      def self.documented_as_reader(*args)   # :nodoc:
+      end
+      
+      # :type1, :truetype
+      attr_accessor :outlinetype
+      
+      # Hash of glyphs in the font. 
+      attr_accessor :chars
+
+      # The filename of the just read metric file. Does not contain the
+      # path. To set, change the pathname
+      documented_as_reader :filename
+
+      # Absolute pathname of the metric file. Not checked when set.
+      attr_accessor :pathname
+      
+      # File name of the font containing the outlines (the file that needs
+      # to be put into the pdf-file). The .tt or the .pfb file. If unset
+      # use the value of filename, but changed to the correct extension in
+      # case of Type 1 fonts.
+      documented_as_accessor :fontfilename
+
+      # Some unique name of the font. Use the filename of the font or a
+      # name after the KB naming schema. Do not add an extension such as
+      # afm or tt.
+      attr_accessor :name
+      
+      # family name of the font
+      attr_accessor :familyname
+
+      # xheight in 1/1000 of an em
+      attr_accessor :xheight
+
+      attr_accessor :weight
+
+      # natural width of a space
+      documented_as_reader :space
+      
+      attr_accessor :italicangle
+
+      # True if the font is a monospaced font (courier for example).
+      attr_accessor :isfixedpitch
+
+      # The official name of the font as supplied by the vendor. Written
+      # as FontName in the afm file.
+      attr_accessor :fontname
+
+      # The full name of the font, whatever this means. Written as
+      # FullName in the afm file.
+      attr_accessor :fullname
+
+      # Class for new glyphs. Default is Glyph
+      attr_accessor :glyph_class
+
+      def Metric.read(filename,options={})
+        case File.extname(filename)
+        when ".afm"
+          require 'rfil/font/afm'
+          return AFM.new(options).read(filename)
+        when ".ttf"
+          require 'rfil/font/truetype'
+          return TrueType.new(options).read(filename)
+        else
+          raise ArgumentError, "Unknown filetype: #{File.basename(filename)}"
+        end
+      end
+      
+      def initialize
+        @chars=Hash.new
+        @xheight=nil
+        @glyph_class=Glyph
+        @outlinetype=nil
+        @info={}
+        @fontfilename=nil
+        @efactor=1.0
+        @slantfactor=0.0
+        @pathname=nil
+      end
+
+      # Factory for new glyphs. Return new instance of glyph_class (see
+      # Attributes).
+      def new_glyph
+        @glyph_class.new
+      end
+      
+
+      def space  # :nodoc:
+        chars['space'].wx
+      end
+
+      def filename # :nodoc: 
+        File.basename(@pathname)
+      end
+
+      def fontfilename= (obj)  # :nodoc:
+        @fontfilename=obj
+      end
+      
+      # This one is documented in the 'attributes' section. If the global
+      # variable is unset, just use @filename, perhaps change afm to pfb
+      def fontfilename # :nodoc:
+        return @fontfilename if @fontfilename
+        case filename
+        when /\.afm$/
+          return filename.chomp(".afm") + ".pfb"
+        when /\.tt$/
+          return filename
+        end
+      end
+
+      # Return all relevant part of pyhsical font. May be used for
+      # copying all files.
+      def fontfilenames
+        raise ScriptError, "not implemented"
+      end
+    end
+  end
+end

data/lib/rfil/font/truetype.rb

@@ -0,0 +1,35 @@
+# truetype.rb -- read truetype font metrics
+#--
+# Last Change: Mi 24 Mai 2006 16:42:47 CEST
+#++
+
+require 'rfil/font/afm'
+
+module RFIL
+  module Font
+    # Read TrueType fonts. Use like the AFM class.
+    class TrueType < AFM
+      def initialize(options={})
+        super
+        @outlinetype=:truetype
+      end
+
+      # all relevant filenames of the font
+      def fontfilenames
+        return {:truetype => File.basename( @fontfilename || filename) }
+      end
+      
+      def read(filename)
+        @filename=File.basename(filename)
+        @fontfilename=filename
+        @name=@filename.chomp(".ttf")
+        self.pathname=Pathname.new(filename).realpath.to_s
+        a=`ttf2afm #{@fontfilename}`
+        parse(a)
+        # ttf2afm does not give an xheight!?
+        @xheight=@chars['x'].ury unless @xheight
+        self
+      end
+    end
+  end
+end

data/lib/rfil/fontcollection.rb

@@ -0,0 +1,182 @@
+#--
+# fontcollection.rb
+# Last Change: Tue May 16 19:02:11 2006
+#++
+
+require 'rfil/rfi'
+require 'rfil/font'
+require 'rfil/helper'
+
+module RFIL # :nodoc: 
+  class RFI
+    # A set of fonts (regular,bold,italic). Used to write an fd-file for
+    # LaTeX or a typescript for ConTeXt. Register different fonts and set
+    # encodings, so you dont't have to specify them in each font.
+    
+    class FontCollection
+      include Helper
+      def self.documented_as_accessor(*args) # :nodoc:
+      end 
+      def self.documented_as_reader(*args) # :nodoc:
+      end 
+
+      attr_accessor :vendor
+
+      # attr_accessor :fontname
+      
+      # Name of the font (collection)
+      attr_accessor :name
+      
+      # One object or one or more objects in an array that describe the
+      # encoding of the postscript font. Object can either be a string
+      # that represents the filename of the encoding ("8r.enc", "8r") or
+      # an ENC object that already contains the encoding
+      documented_as_accessor :mapenc
+
+      # One object or one ore more objects in an array that describe the
+      # encoding of the font TeX expects. Object can either be a string
+      # that represents the filename of the encoding ("8r.enc", "8r") or
+      # an ENC object that already contains the encoding
+      documented_as_accessor :texenc
+
+      # hash of directories for writing files. Default to current working
+      # directory. The setting in the Font object overrides the setting here.
+      attr_accessor :dirs
+
+      attr_accessor :fonts
+
+      # sans, roman, typewriter
+      attr_accessor :style
+
+      attr_accessor :write_vf
+
+      attr_accessor :options
+      
+      # list of temps
+      documented_as_reader :plugins
+      
+      def initialize()
+        @kpse=Kpathsea.new
+        @basedir=nil
+        @name=nil
+        @texenc=nil
+        @mapenc=nil
+        @write_vf=true
+        @fonts=[]
+        @options={:verbose=>false,:dryrun=>false}
+        @style=nil
+        @dirs={}
+        @vendor=nil
+        @fontname=nil
+        set_dirs(Dir.getwd)
+        @plugins={}
+        # find temps-plugins
+        $:.each{ |d|
+          a=Dir.glob(d+"/rfil/rfi_plugin_*.rb")
+          a.each{ |f|
+            require f
+          }
+        }
+        ObjectSpace.each_object(Class){ |x|
+          if Plugin > x
+            t = x.new(self)
+            n = t.name
+            if @plugins.has_key?(n)
+              raise "Name already registered"
+            end
+            @plugins[n]=t
+          end
+        }
+        # done initializing plugins
+      end
+      
+      # Add a font to the collection. Return the number of the font.
+      def register_font (font)
+        unless font.respond_to?(:maplines)
+          raise ArgumentError, "parameter does not look like a font"
+        end
+        fontnumber=@fonts.size
+        @fonts << font
+        return fontnumber
+      end
+      
+      def run_plugin(name)
+
+        raise "don't know plugin #{name}" unless @plugins.has_key?(name)
+        
+        # doc for run_plugin
+        # Return the contents of the file that should be used by the TeX
+        # macro package, i.e a typescript for ConTeXt or an fd-file for
+        # Context. Return value is an Array of Hashes. The Hash has three
+        # different keys:
+        # [<tt>:type</tt>] The type of the file, should be either <tt>:fd</tt> or <tt>:typescript</tt>.
+        # [<tt>:filename</tt>] the filename (without a path) of the file
+        # [<tt>:contents</tt>] the contents of the file.
+
+        files=@plugins[name].run_plugin
+        if files.respond_to?(:each)
+          files.each { |fh|
+            dir=get_dir(fh[:type])
+            filename=File.join(dir,fh[:filename])
+            puts "writing file #{filename}" if @options[:verbose]
+            
+            unless @options[:dryrun]
+              ensure_dir(dir)
+              File.open(filename,"w") { |f| f << fh[:contents] }              
+            end
+          }
+        end
+      end
+      def plugins #:nodoc:
+        @plugins.keys
+      end
+      def mapfile
+        mapfile=[]
+        @fonts.each {|font|
+          mapfile << font.maplines
+        }
+        mapfile.flatten
+      end
+      def mapenc        # :nodoc:
+        return nil if @mapenc==:none
+        @mapenc
+      end
+      def mapenc= (enc)  # :nodoc:
+        set_mapenc(enc)
+      end
+      def texenc       # :nodoc:
+        if @texenc
+          @texenc
+        else
+          # @texenc not set
+          ret=nil
+          @kpse.open_file("8a.enc","enc") { |f|
+            ret = [ENC.new(f)]
+          }
+          return ret
+        end
+      end
+      def texenc= (enc) # :nodoc:
+        @texenc=[]
+        set_encarray(enc,@texenc)
+      end
+      def get_dir(type)
+        @dirs[type]
+      end
+      def write_files(options={})
+        mapdir=get_dir(:map); ensure_dir(mapdir)
+        
+        @fonts.each {|font|
+          font.write_files(:mapfile => false)
+          mapfile << font.maplines
+        }
+        mapfilename=File.join(mapdir,@name+".map")
+        unless options[:dryrun]==true
+          File.open(mapfilename, "w") {|file|
+            file << mapfile.to_s
+          }
+        end
+      end
+    end
+  end # class RFI
+end # module RFIL

data/lib/rfil/helper.rb

@@ -0,0 +1,155 @@
+#--
+# helper.rb Last Change: Fri Jul  1 14:29:09 2005
+#++
+# Helper module for Font and FontCollection.
+
+# Here we define methods that are used in Font and FontCollection. 
+
+require 'fileutils'
+require 'tex/kpathsea'
+
+module RFIL # :nodoc: 
+  class RFI
+    module Helper
+      include TeX
+      def set_encarray(enc,where) #:nodoc:
+        if enc.instance_of?(TeX::ENC)
+          where.push(enc)
+        else
+          enc.each { |e|
+            if e.instance_of?(String)
+              e = e.chomp(".enc") + ".enc"
+              f=@kpse.open_file(e,"enc")
+              where.push(TeX::ENC.new(f))
+              f.close
+            elsif e.instance_of?(TeX::ENC)
+              where.push(e)
+            end
+          }
+        end
+      end
+      def set_mapenc(enc) # :nodoc:
+        @mapenc=enc
+        
+        # nil/:none is perfectly valid
+        return if enc==nil or enc==:none
+        
+        if enc.instance_of?(TeX::ENC)
+          @mapenc = enc
+        else
+          enc.find { |e|
+            if e.instance_of?(String)
+              e = e.chomp(".enc") + ".enc"
+              @kpse.open_file(e,"enc") { |f|
+                @mapenc = TeX::ENC.new(f)
+              }
+            elsif e.instance_of?(TeX::ENC)
+              @mapenc = e
+            end
+          }
+        end
+      end
+      # call-seq:
+      #   set_dirs(string)
+      #   set_dirs(hash)
+      #
+      # Set the base dir of all font related files. Acts only as a storage
+      # for the information. The automatic font installation method in
+      # Font#write_files uses this information. When a _string_ is passed,
+      # use this as the base dir for all files, when a hash is given, the
+      # keys must be one of <tt>:afm</tt>, <tt>:tfm</tt>, 
+      # <tt>:vf</tt>,<tt>:map</tt>, <tt>:pfb</tt>, <tt>:tt</tt>, <tt>:tds</tt>. 
+      def set_dirs(arg)
+        # tds needs testing! set vendor/fonname before/after set_dirs
+        types=[:afm, :tfm, :vpl, :vf, :pl, :map, :type1,:truetype, :fd, :typescript]
+        if arg.instance_of? String
+          @basedir=arg
+          types.each { |sym|
+            @dirs[sym]=arg
+          }
+        elsif arg.instance_of? Hash
+          if arg[:base]
+            @basedir=arg[:base]
+          end
+          if arg[:tds]==true
+            suffix = if @vendor and @name
+                       File.join(@vendor,@name)
+                     else
+                       ""
+                     end
+            types.each { |t|
+              subdir= case t
+                      when :afm
+                        File.join("fonts/afm",suffix)
+                      when :tfm
+                        File.join("fonts/tfm",suffix)
+                      when :vpl
+                        File.join("fonts/source/vpl",suffix)
+                      when :vf
+                        File.join("fonts/vf",suffix)
+                      when :pl
+                        File.join("fonts/source/pl",suffix)
+                      when :map
+                        "fonts/map/dvips"
+                      when :type1
+                        File.join("fonts/type1",suffix)
+                      when :truetype
+                        File.join("fonts/truetype",suffix)
+                      when :fd
+                        File.join("tex/latex",suffix)
+                      when :typescript
+                        File.join("tex/context",suffix)
+                      else
+                        raise "unknown type"
+                      end
+              @dirs[t] = File.join(@basedir,subdir)
+            }
+          else
+            arg.each { |key,value|
+              @dirs[key] = value
+            }
+          end
+        end
+      end
+      def ensure_dir(dirname) # :nodoc:
+        if File.exists?(dirname)
+          if File.directory?(dirname)
+            # nothing to do
+          else
+            # exists, but not dir
+            raise "File exists, but is not a directory: #{dirname}"
+          end
+        else
+          # file does not exist, we can create a directory (hopefully)
+          
+          puts "Creating directory hierarchy #{dirname}" if @options[:verbose]
+          
+          unless @options[:dryrun]
+            FileUtils.mkdir_p(dirname)
+          end
+        end
+      end #ensure_dir
+    end # helper
+    # options is a hash, but with lookup to a fontcollection
+    class Options   # :nodoc:
+      def initialize(fontcollection)
+        @fc=fontcollection
+        @options={}
+      end
+      def [](idx)
+        if @options[idx]
+          return @options[idx]
+        end
+        if @fc
+          @fc.options[idx]
+        else
+          nil
+        end
+      end
+      def []=(idx,obj)
+        @options[idx]=obj
+      end
+      
+    end
+  end  # RFI
+end