RubyGems - hierogloss - Versions diffs - 0.0.1 - Mend

hierogloss 0.0.1

Files changed (37) hide show

checksums.yaml +7 -0
data/.gitignore +19 -0
data/.travis.yml +3 -0
data/GARDINER-LICENSE.txt +6 -0
data/Gemfile +4 -0
data/KRAMDOWN-LICENSE.txt +29 -0
data/LICENSE.txt +15 -0
data/README.md +72 -0
data/Rakefile +8 -0
data/UNICODE-DATA-LICENSE.txt +15 -0
data/UNLICENSE.txt +30 -0
data/assets/fonts/Gardiner.eot +0 -0
data/assets/fonts/Gardiner.otf +0 -0
data/assets/fonts/Gardiner.svg +13593 -0
data/assets/fonts/Gardiner.ttf +0 -0
data/assets/fonts/Gardiner.woff +0 -0
data/bin/hierogloss +25 -0
data/data/Unicode-MdC-Mapping-v1.utf8 +1001 -0
data/data/hierogloss.html.erb +55 -0
data/examples/disjunction.md +13 -0
data/examples/disjunction.png +0 -0
data/examples/liverpool.md +11 -0
data/hierogloss.gemspec +26 -0
data/lib/hierogloss/dictionary.rb +39 -0
data/lib/hierogloss/gloss.rb +174 -0
data/lib/hierogloss/version.rb +3 -0
data/lib/hierogloss.rb +24 -0
data/lib/kramdown/converter/bbcode.rb +113 -0
data/lib/kramdown/converter/htlal.rb +34 -0
data/lib/kramdown/parser/hierogloss.rb +37 -0
data/src/Gardiner.ttf +0 -0
data/test/minitest_helper.rb +4 -0
data/test/test_dictionary.rb +50 -0
data/test/test_gloss.rb +43 -0
data/test/test_hierogloss.rb +7 -0
data/test/test_kramdown_extensions.rb +72 -0
metadata +157 -0

data/data/hierogloss.html.erb ADDED Viewed

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<%
+# This code from Kramdown's default template.
+extend ::Kramdown::Utils::Html
+title = 'Hierogloss'
+h = @converter.root.children.find {|c| c.type == :header}
+if h
+  collector = lambda {|c| c.children.collect {|cc| cc.type == :text ? escape_html(cc.value, :text) : collector.call(cc)}.join('')}
+  title = collector.call(h)
+end
+%>
+    <title><%= title %></title>
+    <meta name="generator" content="hierogloss kramdown <%= ::Kramdown::VERSION %>" />
+    <style type="text/css">
+      @font-face {
+	font-family: 'WebGardiner';
+	src: url('fonts/Gardiner.eot');
+	src: local('☺'), url('fonts/Gardiner.woff') format('woff'), url('fonts/Gardiner.ttf') format('truetype'), url('fonts/Gardiner.svg') format('svg');
+	font-weight: normal;
+	font-style: normal;
+      }
+      .hgls-h, .hgls-l {
+        font-family: "WebGardiner", "Aegyptus", "Gardiner", serif;
+      }
+      .hgls-l { font-style: normal; font-size: 18pt; }
+      .hgls-h { font-size: 24px; }
+      .hgls-gloss td { padding-right: 18px; }
+      .hgls-gloss {
+        margin-left: 18px;
+        page-break-inside: avoid;
+      }
+      p.hgls-gloss {
+        margin-top: 0;
+      }
+      table.hgls-gloss a:link, table.hgls-gloss a:visited {
+        color: black;
+        text-decoration: none;
+      }
+      table.hgls-gloss a:hover {
+        text-decoration: underline;
+      }
+    </style>
+  </head>
+  <body>
+<%= @body %>
+  </body>
+</html>

data/examples/disjunction.md ADDED Viewed

@@ -0,0 +1,13 @@
+# Disjunction in Middle Egyptian
+This example is based on one in Allen's excellent [Middle Egyptian: An
+Introduction to the Language and Culture of Hieroglyphs][allen].
+H: 𓊃𓀀𓏤 | 𓊃𓏏𓁐 | 𓂋𓏤𓊪𓅱
+L: s | s.t | r-pw
+G: man | woman | whichever
+T: either [a] man or [a] woman
+You can emphasize an "or" by following the options with {r-pw}.
+[allen]: http://www.amazon.com/Middle-Egyptian-Introduction-Language-Hieroglyphs/dp/0521741440

data/examples/disjunction.png ADDED Viewed

Binary file

data/examples/liverpool.md ADDED Viewed

@@ -0,0 +1,11 @@
+H: 𓃂 | 𓏠𓈖𓍿𓅱𓊵𓏏𓊪 | 𓁹𓈖 | 𓎛𓏌𓏏
+L: wab | mnTw-Htp | ir(w)~n | Hnw.t
+G: prêtre | Mentouhotep | né de | Henout
+H: 𓃂 | 𓂋𓈖𓆑𓋴𓈖𓃀𓅱 | 𓐙𓉻
+L: wab | rnfsnbw | mAa(-xrw)
+G: prêtre | Renef-senebou | juste de voix
+H: 𓅭𓏏𓆑 | 𓎛𓏌𓏏 | 𓁹𓈖 | 𓋞𓈒𓏥𓂝𓂝𓏏 | 𓐙𓉻
+L: sA.t=f | Hnw.t | ir(w) n | nbw(.t)-aat | mAa(.t-xrw)
+G: fille=sa | Henout | née de | Neboutaat | juste de voix

data/hierogloss.gemspec ADDED Viewed

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hierogloss/version'
+Gem::Specification.new do |spec|
+  spec.name          = "hierogloss"
+  spec.version       = Hierogloss::VERSION
+  spec.authors       = ["Eric Kidd"]
+  spec.email         = ["git@randomhacks.net"]
+  spec.description   = %q{Extends the Markdown parser Kramdown to support hieroglyphs, inline multi-column glosses, and output to BBCode for use on forums.  Includes an executable for processing files and a webfont version of the Gardiner signs.}
+  spec.summary       = %q{Markdown extensions for hieroglyphic glosses and BBCode}
+  spec.homepage      = "https://github.com/emk/hierogloss"
+  spec.license       = "Public domain + other open source licenses"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "kramdown", "~> 1.3"
+  spec.add_development_dependency "prawn", "~> 0.14.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/lib/hierogloss/dictionary.rb ADDED Viewed

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+module Hierogloss
+  #:nodoc: Internal dictionary-related utilities.  APIs are not stable.
+  module Dictionary
+    DATA_DIR = File.join(File.dirname(__FILE__), '..', '..', 'data')
+    MDC_MAPPING_PATH = File.join(DATA_DIR, "Unicode-MdC-Mapping-v1.utf8")
+    GARDINER = {}
+    File.open(MDC_MAPPING_PATH, "r:bom|utf-8") do |f|
+      f.each_line do |l|
+        l.chomp!
+        sign, hex, codes, remarks = l.split(/\t/, 4)
+        for code in codes.split(/ /)
+          next unless code =~ /\A[A-Z][0-9]+\z/
+          GARDINER[sign] = code
+        end
+      end
+    end
+    "𓄿𓇋𓏭𓂝𓅱𓏲𓃀𓊪𓆑𓅓𓈖𓂋𓉔𓎛𓐍𓄡𓊃𓋴𓈙𓈎𓎡𓎼𓏏𓍿𓂧𓆓".each_char do |c|
+      GARDINER.delete(c)
+    end
+    # Try to kick things into shape for hierogl.ch.
+    def self.headword(word)
+      hw = word
+      hw.gsub!(/[()]/, '')
+      hw.sub!(/=.*\z/, '')
+      hw.sub!(/\.w?t\z/, 't')
+      hw.sub!(/\..*\z/, '')
+      hw
+    end
+    # Given a Unicode hieroglyph, get the corresponding Gardiner sign.
+    def self.gardiner(sign)
+      GARDINER[sign]
+    end
+  end
+end

data/lib/hierogloss/gloss.rb ADDED Viewed

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+require 'hierogloss/dictionary'
+module Hierogloss
+  #:nodoc:
+  class Row
+    attr_reader :raw_cells
+    def initialize(row_text)
+      @raw_cells = row_text.split(/\|/).map {|c| c.strip }
+    end
+    def span?
+      false
+    end
+    def attributes
+      attrs = {}
+      attrs['class'] = class_attr if class_attr
+      attrs
+    end
+    def class_attr
+      nil
+    end
+    def to_kramdown
+      attrs = attributes
+      tr = Kramdown::Element.new(:tr, nil, attrs)
+      raw_cells.each do |c|
+        td = Kramdown::Element.new(:td)
+        children = cell_to_kramdown(c)
+        if children.kind_of?(Array)
+          td.children.concat(children)
+        else
+          td.children << children
+        end
+        tr.children << td
+      end
+      tr
+    end
+    def cell_to_kramdown(cell)
+      Kramdown::Element.new(:text, cell)
+    end
+    def search_link(query, text)
+      base_url = "http://www.hierogl.ch/hiero/Sp%C3%A9cial:Recherche"
+      escaped_query = CGI.escape(query)
+      url = "#{base_url}?search=#{escaped_query}&go=Lire"
+      link = Kramdown::Element.new(:a, nil, {'href' => url})
+      link.children << Kramdown::Element.new(:text, text)
+      link
+    end
+  end
+  #:nodoc:
+  class HieroglyphRow < Row
+    def class_attr
+      'hgls-h'
+    end
+    def cell_to_kramdown(cell)
+      cell.chars.map do |c|
+        gardiner = Dictionary.gardiner(c)
+        if !gardiner.nil?
+          search_link("Signe:#{gardiner}", c)
+        else
+          Kramdown::Element.new(:text, c)
+        end
+      end
+    end
+  end
+  #:nodoc:
+  class TransliterationRow < Row
+    JR_TRANSLITERATION = {
+      "A" => "ꜣ",
+      "i" => "j",
+      "a" => "ꜥ",
+      "H" => "ḥ",
+      "x" => "ḫ",
+      "X" => "ẖ",
+      "S" => "š",
+      "q" => "ḳ",
+      "K" => "ḳ",
+      "T" => "ṯ",
+      "D" => "ḏ"
+    }
+    def self.fancy(tl)
+      tl.chars.map {|c| JR_TRANSLITERATION[c] || c }.join
+    end
+    def class_attr
+      'hgls-l'
+    end
+    def cell_to_kramdown(cell)
+      fancy = self.class.fancy(cell)
+      search_link(Dictionary.headword(cell), fancy)
+    end
+  end
+  #:nodoc:
+  class TranslationRow
+    attr_reader :text
+    def initialize(row_text)
+      @text = row_text.strip
+    end
+    def span?
+      true
+    end
+    def class_attr
+      'hgls-t'
+    end
+    def to_kramdown
+      em = Kramdown::Element.new(:em, nil)
+      em.children << Kramdown::Element.new(:text, text)
+      em
+    end
+  end
+  #:nodoc:
+  class Gloss
+    attr_reader :rows
+    def initialize(text)
+      @rows = text.lines.map {|l| l.chomp }.map do |row|
+        row =~ /\A(\w+):(.*)\z/
+        raise "C'est quoi, [[#{row}]]\?" unless $1 && $2
+        type =
+          case $1
+          when "H" then HieroglyphRow
+          when "L" then TransliterationRow
+          when "T" then TranslationRow
+          else Row
+          end
+        type.new($2)
+      end
+    end
+    def to_kramdown
+      result = []
+      # Neither Kramdown nor BBCode support rowspans, so we'll just cheat
+      # for now.
+      rows.chunk {|r| r.span? }.each do |spans, rows|
+        if spans
+          rows.each do |r|
+            class_attr = "hgls-gloss #{r.class_attr}"
+            p = Kramdown::Element.new(:p, nil, 'class' => class_attr)
+            p.children << r.to_kramdown
+            result << p
+          end
+        else
+          table = Kramdown::Element.new(:table, nil, { 'class' => 'hgls-gloss' },
+                                        alignment: [])
+          tbody = Kramdown::Element.new(:tbody)
+          table.children << tbody
+          rows.each {|r| tbody.children << r.to_kramdown }
+          result << table
+        end
+      end
+      result
+    end
+  end
+end

data/lib/hierogloss/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Hierogloss
+  VERSION = "0.0.1"
+end

data/lib/hierogloss.rb ADDED Viewed

@@ -0,0 +1,24 @@
+require 'kramdown'
+require "hierogloss/version"
+require "hierogloss/dictionary"
+require "hierogloss/gloss"
+require "kramdown/parser/hierogloss"
+require "kramdown/converter/bbcode"
+# No guarantess of backwards compatibility for this one.
+require "kramdown/converter/htlal"
+# Most of our internal APIs are undocumented at this point, but you
+# can use this gem via Kramdown's APIs.
+#
+#   Kramdown::Document.new(ARGF.read, input: 'hierogloss').to_html
+#
+# Or if you want to post on an online forum, try:
+#
+#   Kramdown::Document.new(ARGF.read, input: 'hierogloss').to_bbcode
+#
+# Note that the BBCode converter does not yet support all available
+# Markdown constructs.  You're welcome to try other kramdown backends;
+# some of them may more-or-less work.
+module Hierogloss
+  # Nothing to do here yet.
+end

data/lib/kramdown/converter/bbcode.rb ADDED Viewed

@@ -0,0 +1,113 @@
+module Kramdown
+  module Converter
+    # Outputs some of the most common Markdown elements as BBCode.
+    # Everything in this class is internal.
+    class Bbcode < Base
+      include ::Kramdown::Utils::Html
+      DISPATCHER = Hash.new {|h,k| h[k] = "convert_#{k}"} #:nodoc:
+      def initialize(root, options)
+        super
+        @stack = []
+      end
+      def convert(el, opts = {})
+        send(DISPATCHER[el.type], el, opts)
+      end
+      def inner(el, opts)
+        @stack.push([el, opts])
+        result = el.children.map do |inner_el|
+          convert(inner_el, options)
+        end
+        @stack.pop
+        result
+      end
+      def convert_header(el, opts)
+        tag("b", nil, inner(el, opts)) + ["\n"]
+      end
+      def convert_p(el, opts)
+        inner(el, opts) + ["\n"]
+      end
+      def convert_blank(el, opts)
+        "\n"
+      end
+      def convert_text(el, opts)
+        # Wouldn't it be nice if we could escape BBCode?
+        el.value.gsub(/\s+/, ' ') # Ignore newlines in raw text.
+      end
+      def convert_em(el, opts)
+        tag("i", nil, inner(el, opts))
+      end
+      def convert_strong(el, opts)
+        tag("b", nil, inner(el, opts))
+      end
+      def convert_a(el, opts)
+        tag("url", el.attr['href'], inner(el, opts))
+      end
+      def convert_smart_quote(el, opts)
+        entity_to_str(smart_quote_entity(el))
+      end
+      def convert_table(el, opts)
+        tag("table", nil, ["\n"] + inner(el, opts))
+      end
+      def convert_tbody(el, opts)
+        inner(el, opts)
+      end
+      def convert_tr(el, opts)
+        tag("tr", nil, inner(el, opts)) + ["\n"]
+      end
+      def convert_td(el, opts)
+        if @stack.last.first.attr['class'] == 'hgls-h'
+          tag("td", nil, tag("size", "24", inner(el, opts)))
+        else
+          tag("td", nil, inner(el, opts))
+        end
+      end
+      def convert_blockquote(el, opts)
+        # No newline because BBCode will add one itself.  We also run
+        # results_to_text so we can clean up trailing newlines.
+        tag("quote", nil, results_to_text(inner(el, opts)))
+      end
+      def convert_codeblock(el, opts)
+        # No newline because BBCode will add one itself.
+        tag("code", nil, el.value.sub(/\n\z/, ''))
+      end
+      def convert_img(el, opts)
+        tag("img", nil, el.attr['src'])
+      end
+      def convert_root(el, opts)
+        results_to_text(inner(el, opts))
+      end
+      def tag(name, arg, content)
+        if arg
+          ["[#{name}=#{arg}]", content, "[/#{name}]"]
+        else
+          ["[#{name}]", content, "[/#{name}]"]
+        end
+      end
+      def results_to_text(results)
+        results.flatten.compact.join.sub(/\n+\z/, '')
+      end
+    end
+  end
+end

data/lib/kramdown/converter/htlal.rb ADDED Viewed

@@ -0,0 +1,34 @@
+module Kramdown
+  module Converter
+    # Outputs some of the most common Markdown elements in a stripped down
+    # BBCode dialect without table support or reliable font size control.
+    # Everything in this class is internal.
+    class Htlal < Bbcode
+      include ::Kramdown::Utils::Html
+      def convert_table(el, opts)
+        inner(el, opts)
+      end
+      def convert_tbody(el, opts)
+        inner(el, opts)
+      end
+      def convert_tr(el, opts)
+        spaced = []
+        inner(el, opts).each do |td|
+          spaced << td << " | "
+        end
+        spaced.pop
+        spaced << "\n"
+        spaced
+      end
+      def convert_td(el, opts)
+        # We'd like to make hieroglyph cells bigger, but that doesn't play
+        # nicely with links.
+        inner(el, opts)
+      end
+    end
+  end
+end

data/lib/kramdown/parser/hierogloss.rb ADDED Viewed

@@ -0,0 +1,37 @@
+module Kramdown
+  module Parser
+    # Parses an extended Kramdown syntax with support for inline glosses.
+    # Everything in this class is internal.
+    class Hierogloss < ::Kramdown::Parser::Kramdown
+      def initialize(source, options)
+        super
+        @span_parsers.unshift(:translit)
+        @block_parsers.unshift(:gloss)
+      end
+      TRANSLIT_START = /{.*?}/
+      def parse_translit
+        @src.pos += @src.matched_size
+        mdc = @src.matched[1..-2]
+        em = Element.new(:em, nil, 'class' => 'hgls-l')
+        em.children <<
+          Element.new(:text, ::Hierogloss::TransliterationRow.fancy(mdc))
+        @tree.children << em
+      end
+      define_parser(:translit, TRANSLIT_START, '{')
+      GLOSS_START = /^(H|L|G|T):/
+      GLOSS_MATCH = /((^(H|L|G|T):.*)\r?\n)*/
+      def parse_gloss
+        start_line_number = @src.current_line_number
+        data = @src.scan(self.class::GLOSS_MATCH)
+        @tree.children.concat(::Hierogloss::Gloss.new(data).to_kramdown)
+        true
+      end
+      define_parser(:gloss, GLOSS_START)
+    end
+  end
+end

data/src/Gardiner.ttf ADDED Viewed

Binary file

data/test/minitest_helper.rb ADDED Viewed

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'hierogloss'
+require 'minitest/autorun'

data/test/test_dictionary.rb ADDED Viewed

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+require 'minitest_helper'
+class TestDictionary < Minitest::Test
+  def assert_hw(headword, word)
+    assert_equal(headword, Hierogloss::Dictionary.headword(word))
+  end
+  def test_should_leave_simple_headwords_alone
+    assert_hw("xr", "xr")
+    assert_hw("Hr", "Hr")
+  end
+  def test_should_strip_parens
+    assert_hw("ny", "n(y)")
+    assert_hw("mAa-Hrw", "mAa(-Hrw)")
+  end
+  def test_should_strip_clitics
+    assert_hw("ir", "ir=n")
+    assert_hw("im", "im=s")
+  end
+  def test_should_remove_dot_before_t
+    assert_hw("Sspt", "Ssp.t")
+    assert_hw("Hmt", "Hm.t")
+  end
+  def test_should_strip_plurals
+    assert_hw("Sspt", "Ssp.wt")
+    assert_hw("hrw", "hrw.w")
+  end
+  def test_should_strip_verb_endings
+    assert_hw("ir", "ir.n=f")
+    assert_hw("Dd", "Dd.n")
+  end
+  def test_should_provide_gardiner_signs_for_most_signs
+    assert_equal("A1", Hierogloss::Dictionary.gardiner("𓀀"))
+    assert_equal("D4", Hierogloss::Dictionary.gardiner("𓁹"))
+  end
+  def test_should_not_provide_gardiner_signs_for_uniliterals
+    # Let's not link these common characters.
+    "𓄿𓇋𓏭𓂝𓅱𓏲𓃀𓊪𓆑𓅓𓈖𓂋𓉔𓎛𓐍𓄡𓊃𓋴𓈙𓈎𓎡𓎼𓏏𓍿𓂧𓆓".each_char do |c|
+      assert_nil(Hierogloss::Dictionary.gardiner(c), "should not translate #{c}")
+    end
+  end
+end

data/test/test_gloss.rb ADDED Viewed

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+require 'minitest_helper'
+class TestGloss < MiniTest::Test
+  include Hierogloss
+  def setup
+    input = <<EOD
+H: 𓊃𓀀𓏤 | 𓊃𓏏𓁐
+L: s | s.t
+G: homme | femme
+T: l'homme et la femme
+EOD
+    @gloss = Hierogloss::Gloss.new(input)
+  end
+  def assert_row(type, raw_cells, row)
+    assert_instance_of(type, row)
+    refute(row.span?)
+    assert_equal(raw_cells, row.raw_cells)
+  end
+  def test_should_parse_gloss_into_appropriate_rows
+    assert_equal(4, @gloss.rows.length)
+    assert_row(HieroglyphRow, ["𓊃𓀀𓏤", "𓊃𓏏𓁐"], @gloss.rows[0])
+    assert_row(TransliterationRow, ["s", "s.t"], @gloss.rows[1])
+    assert_row(Row, ["homme", "femme"], @gloss.rows[2])
+    # Translations don't have cells.
+    assert_instance_of(TranslationRow, @gloss.rows[3])
+    assert(@gloss.rows[3].span?)
+    assert_equal("l'homme et la femme", @gloss.rows[3].text)
+  end
+  def test_should_be_convertible_to_a_list_of_kramdown_elements
+    # We don't actually care what's in there; we just want to render
+    # something plausible.
+    kramdown = @gloss.to_kramdown
+    assert_instance_of(Array, kramdown)
+    assert(kramdown.length > 0)
+    kramdown.each {|k| assert_instance_of(Kramdown::Element, k) }
+  end
+end

data/test/test_hierogloss.rb ADDED Viewed

@@ -0,0 +1,7 @@
+require 'minitest_helper'
+class TestHierogloss < MiniTest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Hierogloss::VERSION
+  end
+end