forkforge 0.0.3

data/lib/forkforge/dsl/handler.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Forkforge
+  class Handler
+    def initialize handler_class, *args
+      @handler = handler_class.split('::').inject(Object) do |mod, clazz|
+        mod.const_get(clazz)
+      end.new *args
+
+      @delayed = []
+    end
+
+    def method_missing method, *args, &block
+      if @handler.respond_to? method
+        @handler.send(method, *args, &block)
+        @delayed.clear
+      else
+        @delayed.unshift "#{method}"
+      end
+    end
+
+    def parse input
+      self.instance_eval %Q{
+        #{File.read input}
+      }
+    end
+  end
+end

data/lib/forkforge/internal/canonical_combining_classes.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require 'forkforge/internal/unicode_data'
+
+module Forkforge
+
+=begin
+  0:	Spacing, split, enclosing, reordrant, and Tibetan subjoined
+  1:	Overlays and interior
+  7:	Nuktas
+  8:	Hiragana/Katakana voicing marks
+  9:	Viramas
+  10:	Start of fixed position classes
+  199:	End of fixed position classes
+  200:	Below left attached
+  202:	Below attached
+  204:	Below right attached
+  208:	Left attached (reordrant around single base character)
+  210:	Right attached
+  212:	Above left attached
+  214:	Above attached
+  216:	Above right attached
+  218:	Below left
+  220:	Below
+  222:	Below right
+  224:	Left (reordrant around single base character)
+  226:	Right
+  228:	Above left
+  230:	Above
+  232:	Above right
+  233:	Double below
+  234:	Double above
+  240:	Below (iota subscript)
+=end
+  module CanonicalCombiningClasses
+    VARIANTS = {
+      '0'    => { name: 'Spacing, split, enclosing, reordrant, and Tibetan subjoined' },
+      '1'    => { name: 'Overlays and interior' },
+      '7'    => { name: 'Nuktas' },
+      '8'    => { name: 'Hiragana/Katakana voicing marks' },
+      '9'    => { name: 'Viramas' },
+      '10'   => { name: 'Start of fixed position classes' },
+      '199'  => { name: 'End of fixed position classes' },
+      '200'  => { name: 'Below left attached' },
+      '202'  => { name: 'Below attached' },
+      '204'  => { name: 'Below right attached' },
+      '208'  => { name: 'Left attached (reordrant around single base character)' },
+      '210'  => { name: 'Right attached' },
+      '212'  => { name: 'Above left attached' },
+      '214'  => { name: 'Above attached' },
+      '216'  => { name: 'Above right attached' },
+      '218'  => { name: 'Below left' }
+      '220'  => { name: 'Below' },
+      '222'  => { name: 'Below right' },
+      '224'  => { name: 'Left (reordrant around single base character)' },
+      '226'  => { name: 'Right' },
+      '228'  => { name: 'Above left' }
+      '230'  => { name: 'Above' },
+      '232'  => { name: 'Above right' },
+      '234'  => { name: 'Double above' },
+      '240'  => { name: 'Below (iota subscript)' }
+    }
+
+    extend self
+  end
+end

data/lib/forkforge/internal/character_decomposition_mapping.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'forkforge/internal/unicode_data'
+
+module Forkforge
+
+=begin
+  <font>    A font variant (e.g. a blackletter form).
+  <noBreak>   A no-break version of a space or hyphen.
+  <initial>   An initial presentation form (Arabic).
+  <medial>    A medial presentation form (Arabic).
+  <final>   A final presentation form (Arabic).
+  <isolated>    An isolated presentation form (Arabic).
+  <circle>    An encircled form.
+  <super>   A superscript form.
+  <sub>   A subscript form.
+  <vertical>    A vertical layout presentation form.
+  <wide>    A wide (or zenkaku) compatibility character.
+  <narrow>    A narrow (or hankaku) compatibility character.
+  <small>   A small variant form (CNS compatibility).
+  <square>    A CJK squared font variant.
+  <fraction>    A vulgar fraction form.
+  <compat>    Otherwise unspecified compatibility character.
+=end
+  module CharacterDecompositionMapping
+    VARIANTS = {
+      font:     { name: 'A font variant (e.g. a blackletter form)' },
+      noBreak:  { name: 'A no-break version of a space or hyphen' },
+      initial:  { name: 'An initial presentation form (Arabic)' },
+      medial:   { name: 'A medial presentation form (Arabic)' },
+      final:    { name: 'A final presentation form (Arabic)' },
+      isolated: { name: 'An isolated presentation form (Arabic)' },
+      circle:   { name: 'An encircled form' },
+      super:    { name: 'A superscript form' },
+      sub:      { name: 'A subscript form' },
+      vertical: { name: 'A vertical layout presentation form' },
+      wide:     { name: 'A wide (or zenkaku) compatibility character' },
+      narrow:   { name: 'A narrow (or hankaku) compatibility character' },
+      small:    { name: 'A small variant form (CNS compatibility)' },
+      square:   { name: 'A CJK squared font variant' },
+      fraction: { name: 'A vulgar fraction form' },
+      compat:   { name: 'Otherwise unspecified compatibility character' }
+    }
+    VARIANTS_UC = VARIANTS.map { |k, v| [ "<#{k}>", v ] }.to_h
+
+    class Tag
+      attr_reader :tag, :sym
+      def initialize str
+        m = "#{str}".match /^<?(#{VARIANTS.keys.join('|')})>?$/
+        @tag, @sym = "<#{m[1]}>", :"#{m[1]}" if MatchData === m
+      end
+      def valid?
+        !@tag.nil? && !@sym.nil?
+      end
+      def self.tag s
+        Tag.new(s)
+      end
+      def self.tag? s
+        self.tag(s).valid?
+      end
+    end
+
+    extend self
+  end
+end

data/lib/forkforge/internal/code_point.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+module Forkforge
+  class CodePoint
+    UNICODE_FIELDS = [
+      :code_point,
+      :character_name,
+      :general_category,
+      :canonical_combining_classes,
+      :bidirectional_category,
+      :character_decomposition_mapping,
+      :decimal_digit_value,
+      :digit_value,
+      :numeric_value,
+      :mirrored,
+      :unicode_1_0_name,
+      :_10646_comment_field,
+      :uppercase_mapping,
+      :lowercase_mapping,
+      :titlecase_mapping
+    ]
+
+    UNICODE_FIELDS.each { |f|
+      class_eval %Q{
+        attr_reader :#{f}
+      }
+    }
+    def initialize hash
+      UNICODE_FIELDS.each { |f|
+        instance_eval %Q{
+          @#{f} = hash[:#{f}]
+        }
+      }
+    end
+    def to_s
+      [@code_point.to_i(16)].pack('U')
+    end
+    def inspect
+      "'#{to_s}' ⇒ [#{@character_name}]"
+    end
+  end
+
+  class CodePoints
+    def initialize hash
+      @hash = hash
+    end
+
+    def filter field, pattern = nil
+      pattern = case pattern
+                when NilClass then /\A.+/ # not empty
+                when Regexp   then pattern
+                else Regexp.new(pattern)
+                end
+      @hash.select { |k, v|
+        v[field.to_sym] =~ pattern
+      }
+    end
+    private :filter
+
+    def select field, pattern = nil
+      CodePoints.new filter field, pattern
+    end
+
+    def inspect
+      @hash.inspect
+    end
+
+    def to_a
+      @hash.values
+    end
+
+    # FIXME is is shallow or deep copy?
+    def to_h
+      @hash.dup
+    end
+
+    def to_s
+      @hash.values.map { |v|
+        CodePoint.new(v).to_s
+      }.join
+    end
+
+    def respond_to? method
+      m = "#{method}".split '_'
+      return !(filter :character_name, /#{m}/i).empty?
+    end
+
+    def method_missing method, *args, &block
+      m, rest = "#{method}".split '_', 2
+      if args.count <= 1 && !(result = filter :character_name, /#{m}/i).empty?
+        result.select! { |k, v|
+          v[:character_decomposition_mapping] =~ case args.first
+            when String then /#{args.first.codepoints.map { |cp| '%04X' % cp }.join('|')}\Z/
+            when Integer then /#{'%04X' % cp}/
+            when Regexp then args.first
+            else /#{args.first}/
+            end
+        } if args.count > 0
+        result.each do |k, v|
+          yield CodePoint.new v
+        end if block_given? && !rest.nil?
+        result = CodePoints.new(result)
+        rest.nil? ? result : result.send(rest.to_sym)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/forkforge/internal/monkeypatches.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+unless NilClass.respond_to? :strip
+  class NilClass
+    def strip
+      nil
+    end
+    def match *args
+      false
+    end
+  end
+end
+
+class Object
+  def vacant?
+    self.nil? ||
+    self.respond_to?(:strip) && self.strip.empty? ||
+    self.respond_to?(:zero?) && self.zero? ||
+    Array === self && self.compact.empty?
+  end
+end
+
+unless Hash.respond_to? :take
+  class Hash
+    def take count, from = 0
+      Hash[self.to_a[from..from+count]]
+    end
+  end
+end
+
+unless Array.respond_to? :to_h
+  class Array
+    def to_h
+      i = 0
+      self.inject({}) { |memo, e|
+        raise TypeError.new("wrong element type #{e.class} at #{i} (expected array)") unless Array === e
+        raise ArgumentError.new("wrong array length at #{i} (expected 2, was #{e.count})") unless e.count == 2
+
+        i += 1
+        memo[e.first] = e.last
+        memo
+      }
+    end
+  end
+end

data/lib/forkforge/internal/special_casing.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'forkforge/internal/monkeypatches'
+
+module Forkforge
+  module SpecialCasing
+    include UnicodeOrgFileFormat
+
+    LOCAL = 'data'
+    REMOTE = 'Public/UNIDATA'
+    FILE = 'SpecialCasing.txt'
+
+    SPECIAL_CASING_FIELDS = [
+      :code_point,
+      :lowercase_mapping,
+      :titlecase_mapping,
+      :uppercase_mapping,
+      :condition_list,
+      :comment
+    ]
+
+    def hash
+      i_hash REMOTE, LOCAL, FILE, SPECIAL_CASING_FIELDS
+    end
+
+    # filter_code_point '00A0' | filter_uppercase_mapping 0xA0 | ...
+    SPECIAL_CASING_FIELDS.each { |method|
+      define_method("filter_#{method}") { |cp, filters = []|
+          return hash[ncp = __to_code_point(cp)].nil? ? \
+            nil : [*hash[ncp]].select { |h|
+                    filters.inject(true) { |memo, f|
+                      memo &&= h[method.to_sym].match f
+                    }
+                  } || [*hash[ncp]].select { |h| h[method.to_sym].vacant? }
+      }
+
+      define_method("all_#{method}") { |pattern = nil|
+        pattern = Regexp.new(pattern) unless pattern.nil? || Regexp === pattern
+        hash.map { |k, v|
+          [
+            k,
+            v.reject { |vv|
+              pattern.nil? ? vv[method.to_sym].vacant? : pattern.match(vv[method.to_sym]).nil?
+            }
+          ]
+        }.to_h
+      }
+    }
+
+    [:uppercase, :lowercase, :titlecase].each { |method|
+      class_eval %Q{
+        def cp_#{method}(cp, lang = nil, context = nil)
+          filters = []
+          filters << Regexp.new('^' + lang + '(?=\\Z|\\s)') unless lang.nil?
+          filters << Regexp.new('(?<=\\A|\\s)' + context + '$') unless context.nil?
+          conditions = filter_condition_list cp, filters
+          (conditions.vacant? || conditions.count != 1 || conditions.first[:#{method}_mapping].vacant? || conditions.first[:#{method}_mapping] == __to_code_point(cp)) ? \
+            cp : conditions.first[:#{method}_mapping].split(' ').map { |cpn| cp_#{method}(cpn.to_i(16), lang, context) }
+        end
+        private :cp_#{method}
+        def #{method}(cp, lang = nil, context = nil)
+          (cpm = cp_#{method}(cp, lang, context)).nil? ? nil : [*cpm].pack('U')
+        end
+      }
+    }
+
+    extend self
+  end
+end

data/lib/forkforge/internal/unicode_data.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'forkforge/internal/monkeypatches'
+require 'forkforge/internal/unicode_org_file'
+require 'forkforge/internal/code_point'
+require 'forkforge/internal/character_decomposition_mapping'
+
+module Forkforge
+  module UnicodeData
+    include UnicodeOrgFileFormat
+
+    LOCAL = 'data'
+    REMOTE = 'Public/UCD/latest/ucd'
+    FILE = 'UnicodeData.txt'
+
+    @cdm = {}
+
+    def hash
+      i_hash(REMOTE, LOCAL, FILE, CodePoint::UNICODE_FIELDS, false)
+    end
+
+    def code_points
+      @codepoints ||= CodePoints.new hash
+    end
+
+    def info cp
+      cp = cp.codepoints.first if String === cp && cp.length == 1
+      hash[__to_code_point(cp)]
+    end
+
+    def infos string
+      string.codepoints.map { |cp| hash[__to_code_point(cp)] }
+    end
+
+    # TODO return true/false whether the normalization was done?
+    def to_char cp, action = :code_point
+      elem = hash[__to_code_point(cp)]
+      __to_char(elem[action].vacant? ? elem[:code_point] : elem[action])
+    end
+
+    def to_codepoint cp
+      Forkforge::CodePoint.new info cp
+    end
+
+    # get_code_point '00A0' | get_character_decomposition_mapping 0xA0 | ...
+    # all_code_point /00[A-C]\d/ | get_character_decomposition_mapping /00A*/ | ...
+    CodePoint::UNICODE_FIELDS.each { |method|
+      define_method("get_#{method}") { |cp|
+        ncp = __to_code_point cp
+        return hash[ncp] ? hash[ncp][method.to_sym] : nil
+      }
+      define_method("all_#{method}") { |pattern = nil|
+        pattern = Regexp.new(pattern) unless pattern.nil? || Regexp === pattern
+        hash.select { |k, v|
+          pattern.nil? ? !v[method.to_sym].vacant? : !pattern.match(v[method.to_sym]).nil?
+        }
+      }
+    }
+
+    def compose_cp cp, tag = :font, thorough = true
+      cp = __to_code_point cp
+      return Forkforge::CodePoint.new(hash[cp]) unless (t = CharacterDecompositionMapping::Tag.tag(tag)).valid?
+
+      @cdm[tag] = all_character_decomposition_mapping(/#{t.tag}/).values if @cdm[tag].nil?
+      # FIXME Could we distinguish “<wide> 0ABC” and “0A00 0ABC” in more elegant way?
+      lmbd = ->(v) { v[:character_decomposition_mapping] =~ /[^\dA-Fa-f]\s+#{cp}\Z/ }
+      thorough ? \
+        @cdm[tag].select(&lmbd).map { |cp| Forkforge::CodePoint.new(cp) } :
+        Forkforge::CodePoint.new(@cdm[tag].find(&lmbd) || hash[cp])
+    end
+
+    def decompose_cp cp, tags = []
+      normalized = __to_code_point cp
+      mapping = get_character_decomposition_mapping cp
+      return normalized if mapping.vacant?
+
+      cps = mapping.split ' '
+
+      return normalized if ![*tags].vacant? && \
+        cps.inject(false) { |memo, cp|
+          memo || (CharacterDecompositionMapping::Tag::tag?(cp) && ![*tags].include?(CharacterDecompositionMapping::Tag::tag(cp).sym))
+        }
+
+      cps.reject { |cp|
+        Forkforge::CharacterDecompositionMapping::Tag::tag? cp
+      }.map { |cp| decompose_cp cp, tags }
+    end
+
+    extend self
+  end
+end

data/lib/forkforge/internal/unicode_org_file.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Forkforge
+  module UnicodeOrgFileFormat
+    HOST = 'www.unicode.org'
+
+    @@hashmap = {}
+
+    def i_grab remote_folder, local_folder, file
+      require 'net/http'
+      Net::HTTP.start(HOST) do |http|
+        resp = http.get "/#{remote_folder}/#{file}"
+        if !File.exist? local_folder
+          require 'fileutils'
+          FileUtils.mkpath local_folder
+        end
+        open("#{local_folder}/#{file}", "wb") do |file|
+          file.write(resp.body.gsub(/^\s*#.*?$/, '').gsub(/\R+/, "\n").gsub(/\A\R+/, ''))
+        end
+      end
+    end
+    private :i_grab
+
+    def i_load remote_folder, local_folder, file
+      i_grab(remote_folder, local_folder, file) unless File.exist? "#{local_folder}/#{file}"
+      File.read "#{local_folder}/#{file}"
+    end
+    private :i_load
+
+    def i_hash remote_folder, local_folder, file, fields, arrayize = true
+      if @@hashmap[self.name].nil?
+        @@hashmap[self.name] = {}
+        i_load(remote_folder, local_folder, file).split(/\R/).each do |line|
+          # comment is always last, while the amount of fields is subject to change
+          comment = line.scan(/(?<=#).*?$/).first.strip
+          line.gsub!(/;\s*#.*$/, '') unless comment.nil?
+          values = line.split ';'
+          key = values.first.strip
+          value = (fields.map { |f|
+                    [ f, values.shift.strip ]
+                  } + [[ :comment, comment ]]).to_h
+          arrayize ? \
+            (@@hashmap[self.name][key] ||= []) << value : \
+            @@hashmap[self.name][key] = value
+        end
+      end
+      @@hashmap[self.name]
+    end
+    private :i_hash
+
+    def __to_code_point cp
+      case cp
+      when Integer then cp = cp.to_s(16)
+      when Forkforge::CodePoint then cp = cp.code_point
+      end
+      '%04X' % cp.to_i(16)
+    end
+
+    def __to_char cp
+      cp = cp.to_s(16) if Integer === cp
+      [cp.to_i(16)].pack('U')
+    end
+
+  end
+end

data/lib/forkforge/knife/string.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'forkforge/unicode'
+
+class String
+
+  def decompose tags = []
+    Forkforge::Unicode::decompose self, tags
+  end
+
+  [:circle, :super, :sub, :wide].each { |m|
+    class_eval %Q{
+      def compose_#{m}
+        Forkforge::Unicode::#{m} self
+      end
+    }
+  }
+
+  [:uppercase, :lowercase].each { |m|
+    class_eval %Q{
+      def #{m} lang = nil, context = nil
+        Forkforge::Unicode::#{m} self, lang, context
+      end
+    }
+  }
+
+  def upcase
+    uppercase
+  end
+
+  def downcase
+    lowercase
+  end
+
+end

data/lib/forkforge/selector.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'forkforge/unicode'
+
+module Forkforge
+  module Selector
+    def self.included base
+      re, basename = nil, base.name.gsub(/.*::/, '')
+      # FILTER = { 'Tagged' => /^<.*?>$/ }
+      if base.const_defined?(:FILTER)
+        filter = base.const_get(:FILTER).to_a.flatten
+        re = filter.last
+        basename = basename.gsub(/^#{filter.first}/, '')
+      end
+      basename = (Forkforge::Unicode::camel_to_underscore basename).to_sym
+
+      # HASH = Forkforge::UnicodeData::all_character_name /^<.*?>$/
+      base.const_set :HASH, UnicodeData::send("all_#{basename}", re)
+
+      # ALL = Forkforge::UnicodeData::all_bidirectional_category.uniq
+      base.const_set :ALL, base::HASH.map { |k, v| v[basename] }.uniq
+
+      base.class_eval %Q{
+        CHARACTERS = HASH.reduce({}) { |memo, v|
+          (memo[v.last[:#{basename}]] ||= []) << v.last
+          memo
+        }
+      }
+
+      base.extend base
+    end
+  end
+
+  module TaggedCharacterName
+    FILTER = { 'Tagged' => /^<.*?>$/ }
+
+    include Selector
+
+    # E. g. def control ⇒ [ ALL_ITEMS_WITH_CONTROL_NAME ]
+    CHARACTERS.each { |k, v|
+      define_method(k.downcase.gsub(/^<|>$/, '').gsub(/\W/, '_')) { v }
+    }
+  end
+
+  module BidirectionalCategory
+    include Selector
+  end
+
+end