tex-hyphen 0.4.0

data/Changelog

@@ -0,0 +1,19 @@
+== TeX::Hyphen 0.4.0
+* This is the final release of TeX::Hyphen for Ruby. The next version will be
+  called Text::Hyphen and will provide significant enhancement to the
+  capabilities of hyphenation as well as an API change.
+* Added bin/hyphen -- a program to demonstrate hyphenation.
+
+== TeX::Hyphen 0.3.1
+* Created a gemspec. Removed some unnecessary scaffolding code.
+
+== TeX::Hyphen 0.3
+* Added caching capabilities to both #hyphenate and #visualise.
+
+== TeX::Hyphen 0.2
+* Added TeX::Hyphen#hyphenate_to(word, size). This is in preparation for a
+  change to Text::Format for hyphenation of words. Created Test::Unit unit
+  tests.
+
+== TeX::Hyphen 0.1
+* Initial Ruby version by Martin DeMello.

data/INSTALL

@@ -0,0 +1,6 @@
+Installing this package is as simple as:
+
+% ruby install.rb
+
+Alternatively, you can use the RubyGem version of TeX::Hyphen available as
+tex-hyphen-0.4.0.gem from the usual sources.

data/README

@@ -0,0 +1,14 @@
+TeX::Hyphen 0.4.0
+Copyright � 2003 - 2004 Martin DeMello and Austin Ziegler
+
+Hyphenates a word according to a TeX pattern file (defaults to Donald E.
+Knuth's hyphen.tex, included in this distribution). This is a straightforward
+port of the perl implementation by Jan Pazdziora
+[http://search.cpan.org/author/JANPAZ/TeX-Hyphen-0.140/lib/TeX/Hyphen.pm].
+Because hyphenation can potentially be an expensive proposition, TeX::Hyphen
+will now return from a cache.
+
+TeX::Hyphen is licensed under the same terms as Ruby or under the GPL version
+2, or later.
+
+This is the last version of TeX::Hyphen.

data/Rakefile

@@ -0,0 +1,116 @@
+#! /usr/bin/env rake
+$LOAD_PATH.unshift('lib')
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'tex/hyphen'
+require 'archive/tar/minitar'
+require 'zlib'
+
+DISTDIR = "tex-hyphen-#{TeX::Hyphen::VERSION}"
+TARDIST = "../#{DISTDIR}.tar.gz"
+
+DATE_RE = %r<(\d{4})[./-]?(\d{2})[./-]?(\d{2})(?:[\sT]?(\d{2})[:.]?(\d{2})[:.]?(\d{2})?)?>
+
+if ENV['RELEASE_DATE']
+  year, month, day, hour, minute, second = DATE_RE.match(ENV['RELEASE_DATE']).captures
+  year ||= 0
+  month ||= 0
+  day ||= 0
+  hour ||= 0
+  minute ||= 0
+  second ||= 0
+  ReleaseDate = Time.mktime(year, month, day, hour, minute, second)
+else
+  ReleaseDate = nil
+end
+
+task :test do |t|
+  require 'test/unit/testsuite'
+  require 'test/unit/ui/console/testrunner'
+
+  runner = Test::Unit::UI::Console::TestRunner
+
+  $LOAD_PATH.unshift('tests')
+  $stderr.puts "Checking for test cases:" if t.verbose
+  Dir['tests/tc_*.rb'].each do |testcase|
+    $stderr.puts "\t#{testcase}" if t.verbose
+    load testcase
+  end
+
+  suite = Test::Unit::TestSuite.new("TeX::Hyphen")
+
+  ObjectSpace.each_object(Class) do |testcase|
+    suite << testcase.suite if testcase < Test::Unit::TestCase
+  end
+
+  runner.run(suite)
+end
+
+spec = eval(File.read("tex-hyphen.gemspec"))
+spec.version = TeX::Hyphen::VERSION
+desc "Build the RubyGem for TeX::Hyphen"
+task :gem => [ :test ]
+Rake::GemPackageTask.new(spec) do |g|
+  g.need_tar    = false
+  g.need_zip    = false
+  g.package_dir = ".."
+end
+
+desc "Build a TeX::Hyphen .tar.gz distribution."
+task :tar => [ TARDIST ]
+file TARDIST => [ :test ] do |t|
+  current = File.basename(Dir.pwd)
+  Dir.chdir("..") do
+    begin
+      files = Dir["#{current}/**/*"].select { |dd| dd !~ %r{(?:/CVS/?|~$)} }
+      files.map! do |dd|
+        ddnew = dd.gsub(/^#{current}/, DISTDIR)
+        mtime = ReleaseDate || File.stat(dd).mtime
+        if File.directory?(dd)
+          { :name => ddnew, :mode => 0755, :dir => true, :mtime => mtime }
+        else
+          if dd =~ %r{bin/}
+            mode = 0755
+          else
+            mode = 0644
+          end
+          data = File.read(dd)
+          { :name => ddnew, :mode => mode, :data => data, :size => data.size,
+            :mtime => mtime }
+        end
+      end
+
+      ff = File.open(t.name.gsub(%r{^\.\./}o, ''), "wb")
+      gz = Zlib::GzipWriter.new(ff)
+      tw = Archive::Tar::Minitar::Writer.new(gz)
+
+      files.each do |entry|
+        if entry[:dir]
+          tw.mkdir(entry[:name], entry)
+        else
+          tw.add_file_simple(entry[:name], entry) { |os| os.write(entry[:data]) }
+        end
+      end
+    ensure
+      tw.close if tw
+      gz.close if gz
+    end
+  end
+end
+task TARDIST => [ :test ]
+
+def sign(file)
+  system %("C:/Program Files/Windows Privacy Tools/GnuPG/gpg.exe" -ba #{file}).gsub(%r{/}) { "\\" }
+  raise "Error signing with GPG." unless File.exists?("#{file}.asc")
+end
+
+task :signtar => [ :tar ] do
+  sign TARDIST
+end
+task :signgem => [ :gem ] do
+  sign "../#{DISTDIR}.gem"
+end
+
+desc "Build everything."
+task :default => [ :signtar, :signgem ]

data/bin/hyphen

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# Text::Hyphen
+#   Copyright 2003 - 2004, Martin DeMello and Austin Ziegler
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: hyphen,v 1.1 2004/12/10 03:56:54 austin Exp $
+#++
+
+require 'optparse'
+require 'ostruct'
+
+begin
+  require 'tex/hyphen'
+rescue LoadError
+  require 'rubygems'
+  require 'tex/hyphen'
+end
+
+options = OpenStruct.new
+options.action = :visualise
+ARGV.options do |opt|
+  opt.banner = "Usage: #{File.basename($0)} [options] [mode] word+"
+  opt.separator ""
+  opt.separator "Modes"
+  opt.on('-V', '--visualise', 'Visualises the hyphenation of the word.', 'Default action.') { |mode|
+    options.action = :visualise
+  }
+  opt.on('-P', '--points', 'Shows the letters on which a word will', 'be hyphenated.') { |mode|
+    options.action = :hyphenate
+  }
+  opt.on('-H', '--hyphenate-to SIZE', Numeric, 'Hyphenates the word so that the first', 'point is at least SIZE letters.') { |size|
+    options.action = :hyphenate_to
+    options.size = size
+  }
+
+  opt.separator ""
+  opt.separator "Options"
+  opt.on('-L', '--left SIZE', 'Sets the minimum number of letters on', 'the left side of the word.') { |left|
+    options.left = left
+  }
+  opt.on('-R', '--right SIZE', 'Sets the minimum number of letters on', 'the right side of the word.') { |right|
+    options.right = right
+  }
+  opt.on('--pattern-file PATTERNS', 'Loads the specified TeX pattern file.') { |file|
+    options.file = file
+  }
+
+  opt.separator ""
+  opt.on_tail('-h', '--help', 'Shows this help') {
+    $stderr.puts opt
+    exit 0
+  }
+  opt.parse!
+end
+
+if ARGV.empty?
+  $stderr.puts ARGV.options
+  exit 0
+end
+
+hyphenator = TeX::Hyphen.new do
+  @min_left   = options.left  if options.left
+  @min_right  = options.right if options.right
+  @style      = 'czech'
+  @file       = options.file  if options.file
+end
+
+case options.action
+when :visualise
+  size = 80
+  ARGV.each do |word|
+    vis = hyphenator.visualise(word)
+    if (size - vis.size - 1) < 0
+      puts
+      size = 80
+    end
+    size -= (vis.size + 1)
+    print "#{vis} "
+  end
+when :hyphenate
+  ARGV.each do |word|
+    hyp = hyphenator.hyphenate(word)
+    print "#{word}: "
+    hyp.each { |pt| print "#{word[pt, 1]} " }
+    puts
+  end
+when :hyphenate_to
+  size = 80
+  ARGV.each do |word|
+    vis = hyphenator.visualise_to(word, options.size)
+    if (size - vis.size - 1) < 0
+      puts
+      size = 80
+    end
+    size -= (vis.size + 1)
+    print "#{vis} "
+  end
+end

data/lib/tex/hyphen/czech.rb

@@ -0,0 +1,116 @@
+module TeX #:nodoc:
+  class Hyphen #:nodoc:
+      # = TeX::Hyphen::Czech
+      #
+      # Provides parsing routine for Czech patterns
+      #
+      # == Synopsis
+      #   require 'tex/hyphen'
+      #   hyp = TeX::Hyphen.new
+      #     # Default hyphenation style is 'czech'
+      #
+      # == Description
+      # This pattern processing happens to be the default. If you need to
+      # write you own style of parsing the pattern file, you might want to
+      # start with this file and hack it to suit your needs. There is nothing
+      # for end users here -- just specify the style parameter in call to new
+      # TeX::Hyphen.
+      #
+      # The language style specific modules have to define the following
+      # functions:
+      #
+      # * process_patterns
+      # * process_hyphenation
+      #
+      # Check the 'tex/hyphen/czech.rb' source to see the exact form of
+      # the values inserted into these has structures.
+      #
+      # Each style module should also define DEFAULT_STYLE_MIN_LEFT and
+      # DEFAULT_STYLE_MIN_RIGHT global variables, if they have different
+      # values than the default 2. The values should match the paratemers used
+      # to generate the patterns. Since various pattern files could be
+      # generated with different values set, this is just a default that can
+      # be changed with parameters to the TeX::Hyphen constructor.
+      #
+      # Note: the encoding for this is ISO-8859-1 or ISO-8859-15.
+    module Czech
+    private
+      BACKV  = { 'c' => '�', 'd' => '�', 'e' => '�', 'l' => '�', 'n' => '�',
+                 'r' => '�', 's' => '�', 't' => '�', 'z' => '�', 'C' => '�',
+                 'D' => '�', 'E' => '�', 'L' => '�', 'N' => '�', 'R' => '�',
+                 'S' => '�', 'T' => '�', 'Z' => '�' }
+      BACKAP = { 'a' => '�', 'e' => '�', 'i' => '�', 'l' => '�', 'o' => '�',
+                 'u' => '�', 'y' => '�', 'A' => '�', 'E' => '�', 'I' => '�',
+                 'L' => '�', 'O' => '�', 'U' => '�', 'Y' => '�' }
+
+      STYLE_VERSION = '0.121'
+
+      DEFAULT_STYLE_MIN_LEFT  = 2
+      DEFAULT_STYLE_MIN_RIGHT = 2
+
+      def cstolower(e)
+				e.tr('A-Z��������ť�����ة�����ݬ�', 'a-z������������������������')
+      end
+
+        # This method gets individual lines of the \patterns content. It
+        # should parse these lines, and fill values in @both_hyphen,
+        # @begin_hyphen, @end_hyphen and @hyphen, members of the class. The
+        # function should return false if end of the pattern section (macro)
+        # was reached, 1 if the parsing should continue.
+      def process_patterns(line)
+        return false if (line =~ /\}/)
+
+        line.split(/\s+/).each do |w|
+          next if w.empty?
+
+          start = stop = false
+
+          start = true if w.sub!(/^\./, '')
+          stop = true if w.sub!(/\.$/, '')
+
+          w.gsub!(/\\v\s+(.)/) { BACKV[$1] }    # Process the \v tag
+          w.gsub!(/\\'(.)/) { BACKAP[$1] }      # Process the \' tag
+          w.gsub!(/\^\^(..)/) { $1.hex.to_s }  # convert things like ^^fc
+
+          w.gsub!(/(\D)(?=\D)/) { "#{$1}0" }    # insert zeroes
+          w.gsub!(/^(?=\D)/, '0')               # and start with some digit
+
+          #tag = cstolower(w.gsub(/\d/, ''))     # get the lowercase string...
+          tag = w.gsub(/\d/, '')
+          value = w.gsub(/\D/, '')              # and numbers apart
+          tag = cstolower(tag)
+            # The Perl maintainers say: (if we knew locales were fine
+            # everywhere, we could use them)
+
+          if (start and stop)
+						@both_hyphen[tag] = value
+					elsif (start)
+						@begin_hyphen[tag] = value
+					elsif (stop)
+						@end_hyphen[tag] = value
+					else
+						@hyphen[tag] = value
+          end
+        end
+        true
+      end
+
+        # This method gets the lines of the \hyphenation content. It should
+        # parse these lines and fill values into exception which is passed as
+        # second parameter upon call. The function should return 0 if end of
+        # the exception section (macro) was reached, 1 if the parsing should
+        # continue.
+      def process_hyphenation(line)
+        return false if line =~ /\}/
+
+        l = line.gsub(/\\v\s+(.)/) { BACKV[$1] }
+        l.gsub!(/\\'(.)/) { BACKAP{$1} }
+        tag = cstolower(l.gsub(/-/, ''))
+        value = "0" + l.gsub(/[^-](?=[^-])/, '0').gsub(/[^-]-/, '1')
+        value.gsub!(/[^01]/, '0')
+        @exception[tag] = value
+        true
+      end
+    end
+  end
+end

data/lib/tex/hyphen/german.rb

@@ -0,0 +1,93 @@
+module TeX #:nodoc:
+  class Hyphen #:nodoc:
+      # = TeX::Hyphen::German
+      #
+      # Provides parsing routines for German patterns.
+      #
+      # == Synopsis
+      #   require 'tex/hyphen'
+      #   hyp = TeX::Hyphen.new(:style => 'german')
+      #
+      # See Tex::Hyphen::Czech for more information.
+    module German
+      BACKV  = { 'c' => '�', 'd' => '�', 'e' => '�', 'l' => '�', 'n' => '�',
+                 'r' => '�', 's' => '�', 't' => '�', 'z' => '�', 'C' => '�',
+                 'D' => '�', 'E' => '�', 'L' => '�', 'N' => '�', 'R' => '�',
+                 'S' => '�', 'T' => '�', 'Z' => '�' }
+      BACKAP = { 'a' => '�', 'e' => '�', 'i' => '�', 'l' => '�', 'o' => '�',
+                 'u' => '�', 'y' => '�', 'A' => '�', 'E' => '�', 'I' => '�',
+                 'L' => '�', 'O' => '�', 'U' => '�', 'Y' => '�' }
+
+      GERMAN = { 'a' => "�", 'o' => "�", 'u' => "�", '3' => "�", 'A' => "�",
+                 'O' => "�", 'U' => "�" }
+
+      STYLE_VERSION = '0.121'
+
+      DEFAULT_STYLE_MIN_LEFT  = 2
+      DEFAULT_STYLE_MIN_RIGHT = 2
+
+    private
+      def cstolower(e)
+        e.tr('A-Z��������ť�����ة�����ݬ�', 'a-z������������������������')
+      end
+
+        # This method gets individual lines of the \patterns content. It
+        # should parse these lines, and fill values in @both_hyphen,
+        # @begin_hyphen, @end_hyphen and @hyphen, members of the class. The
+        # function should return false if end of the pattern section (macro)
+        # was reached, 1 if the parsing should continue.
+      def process_patterns(line)
+        return false if line =~ /\endgroup/ || line =~ /\}/
+
+        line.split(/\s+/).each do |w|
+          next if w.empty?
+
+          start = stop = false
+
+          start = true if w.sub!(/^\./, '')
+          stop = true if w.sub!(/\.$/, '')
+
+          w.gsub!(/\\n\{([^\}]+)\}/) { $1 }
+          w.gsub!(/\"(aouAOU3)/) { GERMAN[$1] } # Process \" German tags
+          w.gsub!(/\\v\s+(.)/) { BACKV[$1] }    # Process the \v tag
+          w.gsub!(/\\'(.)/) { BACKAP[$1] }      # Process the \' tag
+          w.gsub!(/\^\^(..))/) { $1.hex.to_s }  # convert things like ^^fc
+          w.gsub!(/(\D)(?=\D)/) { "#{$1}0" }    # insert zeroes
+          w.gsub!(/^(?=\D)/, '0')               # and start with some digit
+          tag = cstolower(w.gsub(/\d/, ''))     # get the lowercase string...
+          value = w.gsub(/\D/, '')              # and numbers apart
+            # The Perl maintainers say: (if we knew locales were fine
+            # everywhere, we could use them)
+
+          if (start and stop)
+            @both_hyphen[tag] = value
+          elsif (start)
+            @begin_hyphen[tag] = value
+          elsif (stop)
+            @end_hyphen[tag] = value
+          else
+            @hyphen[tag] = value
+          end
+        end
+        true
+      end
+
+        # This method gets the lines of the \hyphenation content. It should
+        # parse these lines and fill values into exception which is passed as
+        # second parameter upon call. The function should return 0 if end of
+        # the exception section (macro) was reached, 1 if the parsing should
+        # continue.
+      def process_hyphenation(line, exception)
+        return false if line =~ /\}/
+
+        l = line.gsub(/\\v\s+(.)/) { BACKV[$1] }
+        l.gsub!(/\\'(.)/) { BACKAP{$1} }
+        tag = cstolower(l.gsub(/-/, ''))
+        value = "0" + l.gsub(/[^-](?=[^-]/, '0')).gsub(/[^-]-/, '1')
+        value.gsub!(/[^01]/, '0')
+        @exception[tag] = value
+        true
+      end
+    end
+  end
+end