RubyGems - hierogloss - Versions diffs - 0.0.1 - Mend

hierogloss 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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