u 0.5.0 → 1.0.0

data/build/lib/u/build/header/table/row.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Table::Row
+  def initialize(*cells)
+    @cells = cells
+  end
+
+  def <<(cell)
+    @cells << cell
+    self
+  end
+
+  def to_s
+    if @cells.reduce(0){ |i, cell| i + cell.length + 2 } > multi_limit
+      lines = [Line.new]
+      @cells.each_with_index do |cell, i|
+        lines << Line.new if lines.last.length + cell.length + 2 > multi_limit - 3
+        lines.last << cell
+      end
+      multi_format % lines.join(multi_joiner)
+    else
+      single_format % @cells.join(', ')
+    end
+  end
+
+private
+
+  def multi_limit
+    65
+  end
+
+  def multi_format
+    "\t{\n\t\t%s\n\t}"
+  end
+
+  def multi_joiner
+    ",\n\t\t"
+  end
+
+  def single_format
+    "\t{ %s }"
+  end
+
+  class Line
+    def initialize
+      @cells = []
+      @length = 0
+    end
+
+    def <<(cell)
+      @cells << cell
+      @length += cell.length
+      self
+    end
+
+    def length
+      @length + (@cells.length - 1) * 2
+    end
+
+    def to_s
+      @cells.join(', ')
+    end
+  end
+end

data/build/lib/u/build/header/tables.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+module U::Build::Header::Tables
+  require 'u/build/header/tables/intervals'
+  require 'u/build/header/tables/split'
+end

data/build/lib/u/build/header/tables/intervals.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Intervals < U::Build::Header::Table
+  def initialize(points, name)
+    super 'static const struct uint32_t_interval %s[]' % name
+    return if points.empty?
+    sorted = points.sort
+    first = sorted[0]
+    last = first - 1
+    sorted.each do |point|
+      if point == last + 1
+        last += 1
+      else
+        row first, last
+        first = point
+        last = first
+      end
+    end
+    row first, last
+  end
+
+  def to_s
+    '%s%s' % [<<EOH, super]
+struct uint32_t_interval {
+  uint32_t first;
+  uint32_t last;
+};
+
+static int
+u_char_interval_compare(const void *key, const void *element)
+{
+        uint32_t c = *(uint32_t *)key;
+        struct uint32_t_interval *interval = (struct uint32_t_interval *)element;
+
+        if (c < interval->first)
+                return -1;
+        else if (c > interval->last)
+                return +1;
+        else
+                return 0;
+}
+EOH
+  end
+
+private
+
+  def row(first, last)
+    self << U::Build::Header::Table::Row.new('%#06x, %#06x' % [first, last])
+  end
+end

data/build/lib/u/build/header/tables/split.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Split
+  require 'u/build/header/tables/split/row'
+  require 'u/build/header/tables/split/rows'
+  require 'u/build/header/tables/split/data'
+  require 'u/build/header/tables/split/part1'
+  require 'u/build/header/tables/split/part2'
+
+  def initialize(data, type, name)
+    rows = Rows.new(0, data.last){ |c| yield(c) }
+    @data = Data.new('%s %s_data' % [type, name], rows)
+    @part1 = Part1.new('%s_table_part1' % name, 0, data.last_char_part1_i, rows, 0)
+    @part2 = Part2.new('%s_table_part2' % name, data.last, rows, @part1)
+  end
+
+  def to_s
+    "%s\n%s\n%s" % [@data, @part1, @part2]
+  end
+end

data/build/lib/u/build/header/tables/split/data.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Split::Data < U::Build::Header::Table
+  def initialize(declaration, rows)
+    super 'static const %s[][256]' % declaration
+    rows.reject{ |row| row.homogenous? }.each_with_index do |row, index|
+      table_row = Row.new(row.start / 256, index)
+      row.each do |cell|
+        table_row << cell
+      end
+      self << table_row
+    end
+  end
+
+private
+
+  class Row < U::Build::Header::Table::Row
+    def initialize(page, index)
+      super()
+      @format = "\t{ /* page %d, index %d */\n\t\t%%s\n\t}" % [page, index]
+    end
+
+  private
+
+    def multi_format
+      @format
+    end
+  end
+end

data/build/lib/u/build/header/tables/split/part1.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Split::Part1 < U::Build::Header::Table
+  class << self
+    def last_page
+      'UNICODE_LAST_PAGE_PART1'
+    end
+  end
+
+  def initialize(name, first, last, rows, set = 0)
+    super "/* U+%04X through U+%04X */\nstatic const int16_t %s[%s + 1]" % [first, last, name, self.class.last_page]
+    # TODO: Check if we can use each or something, instead, or if we can use
+    # an array for Rows.
+    j = set
+    first.step(last, 256) do |i|
+      row = rows[i / 256]
+      if row.homogenous?
+        self << "\t%s + UNICODE_MAX_TABLE_INDEX" % row[0]
+      else
+        self << "\t%d /* page %d */" % [j, row.start / 256]
+        j += 1
+      end
+    end
+    @set = j
+  end
+
+  attr_reader :set
+end

data/build/lib/u/build/header/tables/split/part2.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Split::Part2 < U::Build::Header::Tables::Split::Part1
+  class << self
+    def last_page
+      'UNICODE_LAST_PAGE_PART2'
+    end
+  end
+
+  def initialize(name, last, rows, part1)
+    super name, 0xe0000, last, rows, part1.set
+  end
+end

data/build/lib/u/build/header/tables/split/row.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Split::Row
+  include Enumerable
+
+  def initialize(start)
+    @start = start
+    @cells = []
+    # TODO: Perhaps don’t cache this if this turns out to be too memory
+    # consuming.
+    @homogenous = true
+    0.upto(255) do |i|
+      @cells[i] = yield(start + i)
+      @homogenous = false if @cells[i] != @cells[0]
+    end
+  end
+
+  def each
+    @cells.each do |cell|
+      yield cell
+    end
+    self
+  end
+
+  def [](index)
+    @cells[index]
+  end
+
+  def homogenous?
+    @homogenous
+  end
+
+  attr_reader :start
+end

data/build/lib/u/build/header/tables/split/rows.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+class U::Build::Header::Tables::Split::Rows
+  include Enumerable
+
+  def initialize(first, last)
+    @rows = []
+    first.step(last, 256) do |i|
+      @rows[i / 256] = U::Build::Header::Tables::Split::Row.new(i){ |c| yield(c) }
+    end
+  end
+
+  def each
+    @rows.each do |row|
+      yield row
+    end
+  end
+
+  def [](index)
+    @rows[index]
+  end
+end

data/build/test/unit/break.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+class Break
+  def initialize(path, method, io = $stdout)
+    io.puts '# -*- coding: utf-8 -*-',
+      '# Automatically generated, so don’t edit!',
+      '',
+      'Expectations do'
+    Lines.new(path).each do |splits|
+      io.printf "  expect [%s] do %s.%s.to_a end\n",
+        splits.map{ |e| uify(e) }.join(', '),
+        uify(splits.join(' ')),
+        method
+    end
+    io.puts 'end'
+  end
+
+private
+
+  def uify(chars)
+    "[%s].pack('U*').u" % chars.split(' ').map{ |e| '0x%04x' % (e == 'D800' ? 0x0001 : e.to_i(16)) }.join(', ')
+  end
+
+  class Lines
+    include Enumerable
+
+    def initialize(path)
+      @path = path
+    end
+
+    def each
+      File.open(@path, 'r') do |file|
+        file.each_line.with_index do |line, index|
+          next if line =~ /\A(?:#|\s*\Z)/
+          yield line.gsub(/\s*\u{d7}\s*/, ' ').
+            sub(/\A\s*\u{f7}\s*/, '').
+            sub(/\s*#.*\Z/, '').
+            split(/\s*\u{f7}\s*/)
+        end
+      end
+    end
+  end
+end
+
+Break.new ARGV[0], ARGV[1]

data/build/test/unit/case.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+
+module Utfify
+  class << self
+    def utfify(codepoints)
+      return '' if codepoints.empty?
+      codepoints.split(/\s+/).map{ |cp| cp.hex }.pack('U*')
+    end
+  end
+end
+
+class SpecialCasing
+  def initialize(path)
+    @entries = []
+
+    Lines.new(path).each do |fields|
+      @entries[fields[Code].hex] =
+        Entry.new(Utfify.utfify(fields[Upper]),
+                  Utfify.utfify(fields[Lower]),
+                  Utfify.utfify(fields[Title]),
+                  fields[Condition])
+    end
+  end
+
+  def include?(code)
+    @entries[code]
+  end
+
+  def [](code)
+    @entries[code]
+  end
+
+  class Entry
+    def initialize(upper, lower, title, condition)
+      @upper, @lower, @title, @condition = upper, lower, title, condition
+    end
+
+    attr_reader :upper, :lower, :title, :condition
+  end
+
+private
+
+  Code, Lower, Title, Upper, Condition = (0..4).to_a
+
+  class Lines
+    include Enumerable
+
+    def initialize(path)
+      @path = path
+    end
+
+    def each
+      File.open(@path, 'rb') do |file|
+        file.each_line.with_index do |line, index|
+          next if line =~ /\A(?:#|\s*\Z)/
+          fields = line.chomp.sub(/\s*;\s*#.*\Z/, '').split(/\s*;\s*/)
+          raise RuntimeError,
+            '%s:%d: wrong number of fields: %d instead of 4..5' %
+              [@path, index + 1, fields.size] unless fields.size.between? 4, 5
+          yield fields
+        end
+      end
+    end
+  end
+end
+
+class UnicodeData
+  include Enumerable
+
+  def initialize(path)
+    @entries = []
+
+    Lines.new(path).each do |code, fields|
+      @entries << Entry.new(code, fields[Category], fields[Upper], fields[Lower])
+    end
+  end
+
+  def each
+    @entries.each do |entry|
+      yield entry
+    end
+  end
+
+  class Entry
+    def initialize(code, category, upper, lower)
+      @code, @category, @upper, @lower = code, category, upper, lower
+    end
+
+    attr_reader :code, :category, :upper, :lower
+  end
+
+private
+
+  Code, Name, Category, _, _, _, _, _, _, _, _, _, Upper, Lower, Title = (0..14).to_a
+
+  class Lines
+    include Enumerable
+
+    def initialize(path)
+      @path = path
+    end
+
+    def each
+      File.open(@path, 'rb') do |file|
+        previous = -1
+        file.each_line.with_index do |line, index|
+          next if line =~ /\A(?:#|\s*\Z)/
+          fields = line.split(';')
+          raise RuntimeError,
+            '%s:%d: wrong number of fields: %d instead of 15' %
+              [@path, index + 1, fields.size] unless fields.size == 15
+          code = fields[Code].hex
+          if code > previous + 1 and fields[Name] =~ /Last>$/ and fields[Category] =~ /^L[lut]$/
+            previous.upto(code - 1) do |c|
+              yield c, fields
+            end
+          end
+          yield code, fields
+          previous = code
+        end
+      end
+    end
+  end
+end
+
+class Case
+  def initialize(special, unicode_data, io = $stdout)
+    @special, @io = special, io
+    @io.puts '# -*- coding: utf-8 -*-',
+      '# Automatically generated, so don’t edit!',
+      '',
+      'Expectations do'
+    unicode_data.each do |entry|
+      generate entry
+    end
+    @io.puts 'end'
+  end
+
+private
+
+  def generate(entry)
+    case entry.category
+    when 'Ll'
+      upcase entry
+    when 'Lu'
+      downcase entry
+    when 'Lt'
+      upcase entry
+      downcase entry
+    end
+  end
+
+  def upcase(entry)
+    if @special.include? entry.code
+      generate1 @special[entry.code].upper, u(entry), :upcase if not @special[entry.code].condition
+    elsif not entry.upper.empty?
+      generate1 Utfify.utfify(entry.upper), u(entry), :upcase
+    end
+  end
+
+  def downcase(entry)
+    if @special.include? entry.code
+      generate1 @special[entry.code].lower, u(entry), :downcase if not @special[entry.code].condition
+    elsif not entry.lower.empty?
+      generate1 Utfify.utfify(entry.lower), u(entry), :downcase
+    end
+  end
+
+  def generate1(expected, u, method)
+    @io.printf "  expect '%s'.u do %s.%s end\n", expected, u, method
+  end
+
+  def u(entry)
+    "'%s'.u" % [entry.code].pack('U*')
+  end
+end
+
+Case.new SpecialCasing.new(ARGV[0]), UnicodeData.new(ARGV[1])