epos 0.9.0

data/lib/epos/entry-parser.rb

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+module Epos
+
+  class EntryParser
+
+    def parse(text)
+
+      entry = {
+        :headword      => nil,
+        :n             => nil,
+        :trademark     => nil,
+        :translation   => nil,
+        :pronunciation => nil,
+        :language      => nil,
+        :first_use     => nil,
+        :orthoepy      => nil,
+        :variants      => [],
+        :old_spelling  => nil,
+        :see           => false,
+        :tabs          => [],
+        :divs          => [],
+      }
+
+      div    = nil
+      defin  = nil
+      either = nil
+
+      text.lines.each do |line|
+        code   = line[0]
+        suffix = line[1..-1].strip
+
+        case code
+
+        when "*"
+          entry[:headword] = suffix
+        when ">"
+          entry[:see] = true
+        when "t"
+          entry[:translation] = suffix
+        when "p"
+          entry[:pronunciation] = suffix
+        when "n"
+          entry[:n] = suffix.to_i
+        when "L"
+          entry[:language] = suffix.split("|")
+        when "®"
+          entry[:trademark] = true
+        when "d"
+          entry[:first_use] = suffix
+        when "o"
+          entry[:orthoepy] = suffix
+        when "M"
+          entry[:variants] = suffix.split("|")
+        when "$"
+          entry[:old_spelling] = suffix
+        when "0"
+          entry[:tabs] << {:type => :grammar, :text => suffix}
+        when "1"
+          entry[:tabs] << {:type => :grammar_usage, :text => suffix}
+        when "2"
+          entry[:tabs] << {:type => :usage, :text => suffix}
+        when "3"
+          entry[:tabs] << {:type => :etymology, :text => suffix}
+        when "4"
+          entry[:tabs] << {:type => :synonyms, :text => suffix}
+        when "5"
+          entry[:tabs] << {:type => :antonyms, :text => suffix}
+        when "6"
+          entry[:tabs] << {:type => :collective, :text => suffix}
+        when "7"
+          entry[:tabs] << {:type => :homonyms, :text => suffix}
+        when "8"
+          entry[:tabs] << {:type => :paronyms, :text => suffix}
+        when "9"
+          entry[:tabs] << {:type => :animals, :text => suffix}
+
+        when "B"
+          div = {
+            :pos        => nil,
+            :idiom      => nil,
+            :field      => nil,
+            :regional   => nil,
+            :register   => nil,
+            :temporal   => nil,
+            :freq       => nil,
+            :plural     => nil,
+            :symbols    => nil,
+            :derivation => nil,
+            :defins     => [],
+          }
+          entry[:divs] << div
+          either = div
+          defin  = nil
+        when "C"
+          div[:pos] = suffix.split("|")
+        when "#"
+          div[:idiom] = suffix
+        when "P"
+          div[:plural] = suffix
+        when "s"
+          div[:symbols] = true
+
+        when "A"
+          defin = {
+            :num        => nil,
+            :text       => nil,
+            :transty     => nil,
+            :examples   => [],
+            :note       => nil,
+            :derivation => nil,
+            :field      => nil,
+            :register   => nil,
+            :freq       => nil,
+            :regional   => nil,
+            :temporal   => nil,
+            :see        => entry[:see],
+          }
+          either = defin
+          div[:defins] << defin
+        when "-"
+          defin[:num] = suffix
+        when ":"
+          defin[:text] = suffix
+        when "r"
+          defin[:transty] = suffix.split("|")
+        when "<"
+          defin[:examples] = suffix.split("|")
+        when "!"
+          defin[:note] = suffix
+        when "D"
+          either[:derivation] = suffix.split("|")
+        when "T"
+          either[:field] = suffix.split("|")
+        when "U"
+          either[:register] = suffix.split("|")
+        when "E"
+          either[:freq] = suffix.split("|")
+        when "R"
+          either[:regional] = suffix.split("|")
+        when "I"
+          either[:temporal] = suffix.split("|")
+
+        when "c"  # hidden, apparently
+        when "S"  # unknown
+        when "v"  # unknown
+        when "\\" # coding error
+        else
+          raise "#{code}#{suffix}"
+        end
+      end
+
+      return entry
+    end
+
+  end
+
+end

data/lib/epos/html/attrs.slim

@@ -0,0 +1,14 @@
+- [ATTRS1, ATTRS2, ATTRS3, ATTRS4, ATTRS5].each do |attrs|
+  - existing = attrs.select{|name| data[name]}
+  - if existing.length > 0
+    p.attrs
+      - existing.each_with_index do |(name, label), index|
+        - if index > 0
+          = '; ' 
+        - if label
+          span.label = label
+        - if data[name].is_a?(String) || data[name].is_a?(Array)
+          - if label
+            = ' '
+          span class=('value ' + name.to_s.gsub(/_/, '-'))
+            == render_text(data[name].is_a?(String) ? data[name] : data[name][@string_index])

data/lib/epos/html/defin-body.slim

@@ -0,0 +1,8 @@
+- if data[:text]
+  p.defin
+    - if data[:see]
+      = "→ "
+    == render_text(data[:text])
+  == render(:attrs, data)
+  - data[:examples].each do |example|
+    p.example == render_text(example)

data/lib/epos/html/defins.slim

@@ -0,0 +1,8 @@
+- if data.length == 1 && !data.first[:num]
+  == render(:defin_body, data.first)
+- else
+  table
+    - data.each do |defin|
+      tr
+        td.num valign='top' = defin[:num]
+        td == render(:defin_body, defin)

data/lib/epos/html/entry.slim

@@ -0,0 +1,7 @@
+div.epos
+  == render(:headword, data)
+  == render(:senses_tab,  data[:divs].reject{|div| div[:idiom] || div[:symbols]})
+  == render(:symbols_tab, data[:divs].select{|div| div[:symbols]})
+  == render(:idioms_tab,  data[:divs].select{|div| div[:idiom]})
+  - data[:tabs].each do |tab|
+    == render(:extra_tab, tab)

data/lib/epos/html/extra-tab.slim

@@ -0,0 +1,3 @@
+- if data
+  h2 = TABS[data[:type]]
+  == render_text(data[:text])

data/lib/epos/html/headword.slim

@@ -0,0 +1,14 @@
+h1
+  = '■ '
+  - if data[:n]
+    sup = data[:n]
+  - if data[:language]
+    i == render_text(data[:headword])
+  - else
+    == render_text(data[:headword])
+  - vars = data[:variants].map{|var| render_text(var)}
+  - if vars.size > 0
+    == vars[0..-2].map{|alt| ", #{alt}"}.join
+    == " #{OR} "
+    == vars.last
+== render(:attrs, data)

data/lib/epos/html/idioms-tab.slim

@@ -0,0 +1,8 @@
+- if data.length > 0
+  h2 = TABS[:idioms]
+  - data.each do |div|
+    h3.idiom
+      = '‣ '
+      == render_text(div[:idiom]).gsub(/@/, "<span class='no-bold'>#{OR}</span>")
+    == render(:attrs, div)
+    == render(:defins, div[:defins])

data/lib/epos/html/senses-tab.slim

@@ -0,0 +1,8 @@
+- if data.length > 0
+  - if !@unmarked
+    h2 = TABS[:senses]
+  - data.each do |div|
+    - if div[:pos]
+      h3 = div[:pos][@string_index]
+    == render(:attrs, div)
+    == render(:defins, div[:defins])

data/lib/epos/html/style.css

@@ -0,0 +1,54 @@
+.epos{
+  font-family: "Noto Sans", "DejaVu Sans", sans-serif;
+  color: #333333;
+}
+
+.epos h1, .epos h2, .epos h3{
+    margin-bottom: 0;
+    font-weight: bold;
+}
+.epos h3{
+    margin: 0;
+}
+.epos h1{
+    font-size: 120%;
+}
+.epos h2{
+    font-size: 110%;
+}
+.epos h3{
+    font-size: 100%;
+}
+
+.epos td{
+  padding: 0;
+}
+.epos td.num{
+  font-weight: bold;
+  padding-right: 5px;
+}
+
+.epos p{
+  margin: 0;
+}
+.epos p.example{
+  color: #006600;
+  font-style: italic;
+}
+.epos .no-bold{
+  font-weight: normal;
+}
+
+.epos span.label{
+  font-style: italic;
+  color: #2e3e8c;
+}
+.epos span.value{
+  color: #666666;
+}
+.epos span.value.transty{
+  color: #aaaa55;
+}
+.epos span.value.note{
+  color: #aa5555;
+}

data/lib/epos/html/symbols-tab.slim

@@ -0,0 +1,4 @@
+- if data.length > 0
+  h2 = TABS[:symbols]
+  - data.each do |div|
+    == render(:defins, div[:defins])

data/lib/epos/html-formatter.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+require 'slim'
+require 'epos/text-parser.rb'
+
+module Epos
+
+  class HtmlFormatter
+
+    def initialize(unmarked: false, compact: false)
+      @unmarked     = unmarked
+      @string_index = compact ? -2 : -1
+      @parser       = TextParser.new
+      @html_base    = File.join(File.dirname(__FILE__), "html")
+
+      load_templates()
+    end
+
+    def format(entry)
+      render(:entry, entry)
+    end
+
+    def style
+      File.read(File.join(@html_base, "style.css"))
+    end
+
+    protected
+
+    def load_templates
+      slim      = Tilt["slim"]
+
+      @templates = [:extra_tab, :symbols_tab, :idioms_tab, :senses_tab, :defins, :defin_body, :attrs, :headword, :entry]
+      @templates = @templates.map{|sym| [sym, slim.new(File.join(@html_base, sym.to_s.gsub(/_/, "-") + ".slim"))]}.to_h
+    end
+
+    def render(item, data)
+      @templates[item].render(self, :data => data)
+    end
+
+    def render_fragment(fragment, format)
+      tags = format.keys.map{|name| FORMATS[name]}
+      raise if tags.index(nil)
+
+      open  = tags        .map{|tag| "<"  + tag[:name] + (tag[:style] ? " style='#{tag[:style]}'" : "") + ">"}.join
+      close = tags.reverse.map{|tag| "</" + tag[:name]                                                  + ">"}.join
+
+      return open + fragment + close
+    end
+     
+    def render_text(text)
+      @parser.parse(text).map{|fragment, format| render_fragment(fragment, format)}.join
+    end
+
+    FORMATS = {
+      "i"      => {:name => "i"},
+      "b"      => {:name => "b"},
+      "super"  => {:name => "sup"},
+      "sub"    => {:name => "sub"},
+      "ul"     => {:name => "span", :style => "text-decoration: underline;"},
+      "f5"     => {:name => "span", :style => "font-variant: small-caps;"},
+      "strike" => {:name => "span", :style => "text-decoration: line-through;"},
+    }
+
+    ATTRS1 = {
+      :field         => "rubrica",
+      :regional      => "regionalismo",
+      :register      => "uso",
+      :temporal      => "diacronismo",
+      :freq          => "estatística",
+      :derivation    => "derivação",
+    }
+    ATTRS2 = {
+      :note          => nil,
+    }
+    ATTRS3 = {
+      :transty       => nil,
+    }
+    ATTRS4 = {
+      :old_spelling  => "forma antiga",
+      :trademark     => "marca registrada",
+      :language      => "língua",
+      :translation   => "tradução",
+      :pronunciation => "pronúncia",
+      :first_use     => "datação",
+      :orthoepy      => "ortoépia",
+    }
+    ATTRS5 = {
+      :plural        => "plural",
+    }
+
+    TABS = {
+      :senses        => "acepções",
+      :idioms        => "locuções",
+      :symbols       => "símbolos e abreviações",
+      :grammar       => "gramática",
+      :grammar_usage => "gramática e uso",
+      :usage         => "uso",
+      :etymology     => "etimologia",
+      :synonyms      => "sinônimos",
+      :antonyms      => "antônimos",
+      :collective    => "coletivos",
+      :homonyms      => "homônimos",
+      :paronyms      => "parônimos",
+      :animals       => "vozes de animais",
+    }
+
+    OR = "ou"
+
+  end
+end

data/lib/epos/index-file.rb

@@ -0,0 +1,35 @@
+require 'epos/encoded-file.rb'
+
+module Epos
+  class IndexFile
+
+    def initialize(path)
+      data = EncodedFile.read(path)
+      lines = data.lines
+      @index = {}
+      lines.each do |line|
+        i = line.index(";")
+        key = line[0..i - 1]
+        val = line[i + 1..-2].to_i
+        if @index.has_key?(key)
+          @index[key] << val
+        else
+          @index[key] = [val]
+        end
+      end
+    end
+
+    def look_up(key)
+      return @index[key] || []
+    end
+
+    def keys
+      return @index.keys
+    end
+
+    def has_key?(key)
+      @index.has_key?(key)
+    end
+
+  end
+end

data/lib/epos/indexed-data-file.rb

@@ -0,0 +1,25 @@
+require 'epos/index-file.rb'
+require 'epos/data-file.rb'
+
+module Epos
+  class IndexedDataFile
+
+    def initialize(index_path, data_path)
+      @index = IndexFile.new(index_path)
+      @data  = DataFile.new(data_path)
+    end
+
+    def look_up(key)
+      @index.look_up(key).map{|pos| @data.read_entry(pos)}
+    end
+
+    def keys
+      @index.keys
+    end
+
+    def has_key?(key)
+      @index.has_key?(key)
+    end
+
+  end
+end

data/lib/epos/search.rb

@@ -0,0 +1,7 @@
+module Epos
+
+  def self.search(string)
+    
+  end
+
+end

data/lib/epos/text-parser.rb

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+require 'epos/cp/f1.rb'
+require 'epos/cp/f2.rb'
+require 'epos/cp/f3.rb'
+require 'epos/cp/f4.rb'
+require 'epos/cp/f6.rb'
+require 'epos/cp/f7.rb'
+require 'epos/cp/f8.rb'
+require 'epos/cp/f9.rb'
+require 'epos/cp/f10.rb'
+require 'epos/cp/f11.rb'
+require 'epos/cp/f12.rb'
+require 'epos/cp/f13.rb'
+require 'epos/cp/f16.rb'
+
+module Epos
+
+  class TextParser
+
+    def parse(text)
+      @result   = []
+      @format   = [{}]
+      @fragment = ""
+      @cmd      = ""
+
+      s    = :reading_fragment
+      code = ""
+
+      text.each_char do |c|
+
+        case s
+
+        when :reading_fragment
+          case c 
+          when "\\"
+            s = :escape_started
+          when "{"
+            self.flush
+            @format << @format.last.clone
+          when "}"
+            self.flush
+            @format.pop if @format.length > 1 # Entry "bum-bum" is broken.
+          else
+            @fragment << c
+          end
+
+        when :escape_started
+          case c
+          when "\\"
+            @fragment << c
+            s = :reading_fragment
+          when "{"
+            @fragment << c
+            s = :reading_fragment
+          when "'"
+            code = ""
+            s = :reading_code
+          else
+            @cmd = c
+            s = :reading_command
+          end
+
+        when :reading_command
+          case c
+          when " "
+            self.command
+            s = :reading_fragment
+          when "\\"
+            self.command
+            s = :escape_started
+          when /[a-z0-9]/
+            @cmd << c
+          when "{"
+            self.command
+            self.flush
+            @format << @format.last.clone
+            s = :reading_fragment
+          when "}"
+            self.command
+            self.flush
+            @format.pop
+            s = :reading_fragment
+          else
+            self.command
+            @fragment << c
+            s = :reading_fragment
+          end
+
+        when :reading_code
+          code << c
+          if code.length == 2
+            @fragment << [code.to_i(16)].pack("U")
+            s = :reading_fragment
+          end
+        end
+      end
+
+      self.command if s == :reading_command
+      self.flush
+
+      return @result
+
+    end
+
+    protected
+
+    CODE_PAGES = {
+      "f1"  => CodePage::F1_MAP,
+      "f2"  => CodePage::F2_MAP,
+      "f3"  => CodePage::F3_MAP,
+      "f4"  => CodePage::F4_MAP,
+      "f6"  => CodePage::F6_MAP,
+      "f7"  => CodePage::F7_MAP,
+      "f8"  => CodePage::F8_MAP,
+      "f9"  => CodePage::F9_MAP,
+      "f10" => CodePage::F10_MAP,
+      "f11" => CodePage::F11_MAP,
+      "f12" => CodePage::F12_MAP,
+      "f13" => CodePage::F13_MAP,
+      "f16" => CodePage::F16_MAP,
+    }
+
+    def convert_encoding(text, f)
+      s = ""
+      cp = CODE_PAGES[f]
+      text.each_char do |c|
+        case
+        when cp[c]
+          s << cp[c]
+        when f == "f1" && !(0x80..0xa0).include?(c.ord)
+          s << c
+        else
+          raise "#{f}:#{c}:#{c.ord.to_s(16)}"
+        end
+      end
+      s
+    end
+
+    def flush
+      format = @format.last
+
+      # This happens *once* ("mico-leão") in all of Houaiss.
+      @fragment.upcase! if format["caps"]
+      format.delete("caps")
+
+      @fragment = self.convert_encoding(@fragment, format["f"] || "f1")
+      format.delete("f")
+
+      @result << [@fragment, format]
+      @fragment = ""
+    end
+
+    def command
+      self.flush if @fragment.length > 0
+
+      case
+      when @cmd =~ /f[0-9][0-9]?/ && @cmd != "f5"
+        @cmd = "f1" if @cmd == "f0"
+        @format.last["f"] = @cmd
+
+      when ["lang1023", "lang1046", "ltrpar", "li100", "sa100", "sb100", "fs20", "fs22", "fs24"].include?(@cmd)
+        # what is this i don't even
+
+      when @cmd == "ulnone"     then @format.last.delete("ul")
+      when @cmd == "i0"         then @format.last.delete("i")
+      when @cmd == "caps0"      then @format.last.delete("caps")
+      when @cmd == "strike0"    then @format.last.delete("strike")
+      when @cmd == "nosupersub" then @format.last.delete("super")
+                                     @format.last.delete("sub")
+
+      when @cmd == "bullet"    then @fragment << "·"
+      when @cmd == "lquote"    then @fragment << "‘"
+      when @cmd == "rquote"    then @fragment << "’"
+      when @cmd == "ldblquote" then @fragment << '“'
+      when @cmd == "rdblquote" then @fragment << '”'
+
+      else
+        @format.last[@cmd] = true
+      end
+
+    end
+
+  end
+end

data/lib/epos.rb

@@ -0,0 +1,9 @@
+require 'epos/data-file.rb'
+require 'epos/dictionary.rb'
+require 'epos/encoded-file.rb'
+require 'epos/entry-parser.rb'
+require 'epos/html-formatter.rb'
+require 'epos/indexed-data-file.rb'
+require 'epos/index-file.rb'
+require 'epos/search.rb'
+require 'epos/text-parser.rb'