u 0.5.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e341d655772c92627d05e82ba10d7ed1e51bd77c
+  data.tar.gz: f48cabee19ae5775bd90baa63b7759e1e6335424
+SHA512:
+  metadata.gz: 40a124a219c3a1b0755fa5b1b1386170bcf801e88cdf1de745abe4f6de7c6d51ba35423ded5c2d4c99cbe8c192b04579fa4b69b7e2611715615fd8e81e87c7b6
+  data.tar.gz: e1803f13f2c604c5e48bdae6b0edf5564eb370dee52ae0c591f7bcc0677d66005fc7a3d59626f134f27e22abee42a371b5a0d07cc5e04550fcbdf5874f8a6257

data/build/ext/u/data/attributes.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+require 'u/build'
+
+class Attributes
+  def initialize(data, special_casing, io = $stdout)
+    U::Build::Header.new(io) do
+      io.puts U::Build::Header::Tables::Split.new(data, 'uint32_t', 'attr'){ |i|
+        special_casing.include?(i) ?
+          '0x%07x' % (0x1000000 + special_casing[i].offset) :
+          '0x%04x' % (data[i].value or 0)
+      }
+      io.puts SpecialCaseTable.new(special_casing)
+    end
+  end
+
+private
+
+  class SpecialCaseTable < U::Build::Header::Table
+    def initialize(special_casing)
+      super '/*
+ * Table of special cases for case conversion; each record contains
+ * First, the best single character mapping to lowercase if Lu,
+ * and to uppercase if Ll, followed by the output mapping for the two cases
+ * other than the case of the codepoint, in the order Ll, Lu, Lt, encoded in
+ * UTF-8, separated and terminated by a NUL character.
+ */
+static const char special_case_table[]'
+      content = []
+      special_casing.each do |special_case|
+        content << (%( "%s\\0" /* offset %d */) % [special_case.to_escaped_s, special_case.offset])
+      end
+      self << content.join("\n")
+    end
+  end
+end
+
+data = Marshal.load(File.open(ARGV[0], 'rb', &:read))
+Attributes.new(data, U::Build::Data::SpecialCasing.new(data, ARGV[1]))

data/build/ext/u/data/bidi-mirroring.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+require 'u/build'
+
+class BidiMirroring
+  def initialize(bidi_mirroring, io = $stdout)
+    U::Build::Header.new(io) do
+      io.puts BidiMirroringTable.new(bidi_mirroring)
+    end
+  end
+
+private
+
+  class BidiMirroringTable < U::Build::Header::Table
+    def initialize(bidi_mirroring)
+      super "static const struct {
+\tuint32_t ch;
+\tuint32_t mirrored_ch;
+} bidi_mirroring_table[]"
+      bidi_mirroring.each do |bidi_mirror|
+        self << U::Build::Header::Table::Row.new('%#06x' % bidi_mirror.char, '%#06x' % bidi_mirror.mirrored)
+      end
+    end
+  end
+end
+
+BidiMirroring.new(U::Build::Data::BidiMirroring.new(ARGV[0]))

data/build/ext/u/data/canonical-combining-class.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+require 'u/build'
+
+class CanonicalCombiningClass
+  def initialize(data, io = $stdout)
+    U::Build::Header.new(io) do
+      io.puts U::Build::Header::Tables::Split.new(data, 'uint8_t', 'canonical_combining_class'){ |i|
+        '%d' % data[i].cclass
+      }
+    end
+  end
+end
+
+CanonicalCombiningClass.new(Marshal.load(File.open(ARGV[0], 'rb', &:read)))

data/build/ext/u/data/case-folding.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+require 'u/build'
+
+class CaseFolding
+  def initialize(casefolding, io = $stdout)
+    U::Build::Header.new(io) do
+      io.puts CasefoldTable.new(casefolding)
+    end
+  end
+
+private
+
+  class CasefoldTable < U::Build::Header::Table
+    def initialize(casefolding)
+      super "/*
+ * Table of casefolding cases that can't be derived by lowercasing.
+ */
+static const struct {
+\tuint16_t ch;
+\tchar data[#{casefolding.map{ |c| c.to_s.bytesize }.max + 1}];
+} casefold_table[]"
+      # TODO: Check that this sort_by will be needed.  (Or should be sorted by
+      # Casefolds
+      casefolding.sort_by{ |c| c.char }.each do |casefold|
+        raise RuntimeError,
+          'casefold_table.ch field too short; upgrade to uint32_t to fit values beyond 0xffff: %s' %
+            casefold.char if
+              casefold.char > 0xffff
+        self << U::Build::Header::Table::Row.new('%#06x' % casefold.char, '"%s"' % casefold.to_escaped_s)
+      end
+    end
+  end
+end
+
+data = Marshal.load(File.open(ARGV[0], 'rb', &:read))
+CaseFolding.new(U::Build::Data::CaseFolding.new(data,
+                                                U::Build::Data::SpecialCasing.new(data, ARGV[1]),
+                                                ARGV[2]))

data/build/ext/u/data/cased.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+require 'u/build'
+
+class Cased
+  Cased = ['Other_Lowercase', 'Other_Uppercase'].freeze
+
+  def initialize(prop_list, io = $stdout)
+    U::Build::Header.new(io) do
+      io.puts U::Build::Header::Tables::Intervals.
+        new(prop_list.
+              select{ |point, properties| properties.any?{ |property| Cased.include? property } }.
+              map{ |point, properties| point },
+            'cased')
+    end
+  end
+end
+
+Cased.new(U::Build::Data::PropList.new(ARGV[0]))

data/build/ext/u/data/compose.rb

@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*-
+
+require 'u/build'
+
+class Compose
+  def initialize(data, composition_exclusions, io = $stdout)
+    compositions = Compositions.new(data, composition_exclusions)
+    firsts = Firsts.new(compositions)
+    seconds = Seconds.new(compositions, firsts)
+    first_singletons, second_singletons, reversals = Singletons.create(compositions, firsts, seconds)
+    values = Values.new(firsts, first_singletons, seconds, second_singletons)
+    U::Build::Header.new(io) do
+      io.puts <<EOH
+#define COMPOSE_FIRST_START #{values.first_start}
+#define COMPOSE_FIRST_SINGLE_START #{values.first_single_start}
+#define COMPOSE_SECOND_START #{values.second_start}
+#define COMPOSE_SECOND_SINGLE_START #{values.second_single_start}
+#define COMPOSE_TABLE_LAST #{values.last / 256}
+EOH
+      io.puts Table.new(0, values.last, 'uint16_t compose_data', 'compose_table'){ |i|
+        values.include?(i) ? values[i].to_s : '0'
+      }
+      io.puts SingletonTable.new(first_singletons, 'compose_first_single')
+      io.puts SingletonTable.new(second_singletons, 'compose_second_single')
+      io.puts ComposeArray.new(firsts, seconds, reversals)
+    end
+  end
+
+private
+
+  class Table
+    def initialize(first, last, data, part1)
+      rows = U::Build::Header::Tables::Split::Rows.new(0, last){ |c| yield(c) }
+      @data = U::Build::Header::Tables::Split::Data.new(data, rows)
+      @part1 = Part1.new(part1, first, last, rows, 0)
+    end
+
+    def to_s
+      "%s\n%s\n" % [@data, @part1]
+    end
+
+    class Part1 < U::Build::Header::Tables::Split::Part1
+      class << self
+        def last_page
+          'COMPOSE_TABLE_LAST'
+        end
+      end
+    end
+  end
+
+  class Compositions
+    include Enumerable
+
+    def initialize(data, composition_exclusions)
+      @entries = []
+      data.each_with_index do |entry, code|
+        next if composition_exclusions.include? code or
+          entry.decomposition.length < 2 or
+          not entry.decomposition.canonical? or
+          data[code].cclass != Starter or
+          data[entry.decomposition.first].cclass != Starter
+        raise RuntimeError,
+          'decomposition of %04X contains more than 2 elements: %d' %
+            [code, entry.decomposition.length] unless
+              entry.decomposition.length == 2
+        @entries << [entry.decomposition.entries, code]
+      end
+    end
+
+    def each_with_index
+      @entries.each do |parts, code|
+        yield parts[0], parts[1], code
+      end
+      self
+    end
+
+    def each
+      @entries.each do |parts, code|
+        yield parts
+      end
+      self
+    end
+
+  private
+
+    Starter = 0
+  end
+
+  class Commons
+    include Enumerable
+
+    def initialize(compositions)
+      @entries = Hash.new(0)
+      compositions.each do |first, second|
+        selection = yield(first, second) and @entries[selection] += 1
+      end
+    end
+
+    def each
+      @entries.keys.sort.each do |code|
+        yield code if @entries[code] > 1
+      end
+      self
+    end
+  end
+
+  class Firsts
+    include Enumerable
+
+    def initialize(compositions)
+      self.commons = Commons.new(compositions){ |first, second| first }
+    end
+
+    def each
+      @entries.each do |code, entry|
+        yield code, entry
+      end
+      self
+    end
+
+    def size
+      @entries.length
+    end
+
+    def include?(code)
+      @entries.include?(code)
+    end
+
+    def [](code)
+      @entries[code]
+    end
+
+  protected
+
+    def commons=(commons)
+      @entries = {}
+      commons.each do |code|
+        @entries[code] = @entries.size
+      end
+      commons
+    end
+  end
+
+  class Seconds < Firsts
+    def initialize(compositions, firsts)
+      self.commons = Commons.new(compositions){ |first, second|
+        second if firsts.include? first
+      }
+    end
+  end
+
+  class Singletons
+    include Enumerable
+
+    class << self
+      def create(compositions, firsts, seconds)
+        first_singletons = []
+        second_singletons = []
+        reversals = Reversals.new
+        compositions.each_with_index do |first, second, code|
+          if firsts.include? first and seconds.include? second
+            reversals[firsts[first], seconds[second]] = code
+          elsif not firsts.include? first
+            first_singletons << Singleton.new(first, second, code)
+          else
+            second_singletons << Singleton.new(second, first, code)
+          end
+        end
+        [new(first_singletons), new(second_singletons), reversals]
+      end
+    end
+
+    def initialize(entries)
+      @entries = entries.sort_by{ |a| a.first }
+    end
+
+    def each
+      @entries.each do |entry|
+        yield entry
+      end
+      self
+    end
+
+    def size
+      @entries.size
+    end
+  end
+
+  class Singleton
+    def initialize(first, second, code)
+      @first, @second, @code = first, second, code
+    end
+
+    attr_reader :first, :second, :code
+  end
+
+  # TODO: Can this be simplified?
+  class Reversals
+    def initialize
+      @entries = {}
+    end
+
+    def []=(first, second, code)
+      @entries[build(first, second)] = code
+    end
+
+    def include?(first, second)
+      @entries.include? build(first, second)
+    end
+
+    def [](first, second)
+      @entries[build(first, second)]
+    end
+
+  private
+
+    def build(first, second)
+      '%s|%s' % [first, second]
+    end
+  end
+
+  class Values
+    def initialize(firsts, first_singletons, seconds, second_singletons)
+      @values = {}
+      @total = 1
+
+      @first_start = @total
+      @first_single_start = @total += set(firsts).size
+      @second_start = @total += singletons(first_singletons).size
+      @second_single_start = @total += set(seconds).size
+      singletons second_singletons
+    end
+
+    def last
+      @values.keys.max
+    end
+
+    attr_reader :first_start, :first_single_start, :second_start, :second_single_start
+
+    def include?(code)
+      @values.include?(code)
+    end
+
+    def [](code)
+      @values[code]
+    end
+
+  protected
+
+    def []=(code, value)
+      @values[code] = value + @total
+    end
+
+  private
+
+    def set(fs)
+      fs.each do |code, value|
+        self[code] = value
+      end
+    end
+
+    def singletons(singletons)
+      singletons.each_with_index do |singleton, code|
+        self[singleton.first] = code
+      end
+    end
+  end
+
+  class SingletonTable < U::Build::Header::Table
+    def initialize(singletons, name)
+      super 'static const uint16_t %s[][2]' % name
+      singletons.each do |singleton|
+        @declaration = 'static const uint32_t %s[][2]' % name if singleton.second > 0xffff or singleton.code > 0xffff
+        self << U::Build::Header::Table::Row.new(*[singleton.second, singleton.code].map{ |c| '%#06x' % c })
+      end
+    end
+  end
+
+  class ComposeArray < U::Build::Header::Table
+    def initialize(firsts, seconds, reversals)
+      @firsts, @seconds, @reversals = firsts, seconds, reversals
+      super 'static const uint16_t compose_array[%d][%d]' % [firsts.size, seconds.size]
+      firsts.size.times do |i|
+        row = U::Build::Header::Table::Row.new
+        seconds.size.times do |j|
+          row <<
+            if reversals.include? i, j
+              raise RuntimeError,
+                'compose_array table field too short; upgrade to uint32_t to fit values beyond 0xffff: %04X' %
+                  reversals[i, j] if
+                    reversals[i, j] > 0xffff
+              '%#06x' % reversals[i, j]
+            else
+              '     0'
+            end
+        end
+        self << row
+      end
+    end
+  end
+end
+
+Compose.new(Marshal.load(File.open(ARGV[0], 'rb', &:read)),
+            U::Build::Data::CompositionExclusions.new(ARGV[1]))