mathtype 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c126bddd1633e3653d495031407818cad1f5a7c0
+  data.tar.gz: 8760f0a03d8fec312fdb017ff0a3fa7208aae165
+SHA512:
+  metadata.gz: 091ecf23a9cdc5280ba0e4b7f64e6b78344a9ca46e41ee802359652b53800ff93cfed0d8c19d4bf1c29dfb76f098ddcfba17f84fb5cd867a3c8a1a545e9cc328
+  data.tar.gz: 9c838f8d116f8d6c7e4945f1b05b5b57fb7ef423de467285941710238de8b2e16d4c271db39e3e328f8599b8f6193c4318cdf6824400521271736d9c677ce716

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mathtype.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jure Triglav
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Mathtype
+
+This gem can read proprietary MathType binary equations that are usually embedded in Word documents and convert these equations into an XML form. This XML form can then be used for further processing, e.g. to convert the equation to MathML.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mathtype'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mathtype
+
+## Usage
+
+To convert a MathType binary equation (e.g. extracted from a Word document) to an XML form:
+
+```
+xml = Mathtype::Converter.new("equation1.bin") # to get the Nokogiri XML object
+puts xml.to_xml # to get the string XML representation
+```
+
+# Testing
+
+Run `bundle exec rspec` to run specs.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mathtype/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/mathtype/version.rb

@@ -0,0 +1,3 @@
+module Mathtype
+  VERSION = "0.0.2"
+end

data/lib/mathtype.rb

@@ -0,0 +1,61 @@
+require "mathtype/version"
+require "bindata"
+require "ole/storage"
+require "nokogiri"
+require_relative "records/mtef.rb"
+
+module Mathtype
+  class Converter
+    attr_reader :xml
+    attr_reader :builder
+    def initialize(equation)
+      ole = Ole::Storage.open(equation, "rb+")
+      eq = ole.file.read("Equation Native")[28..-1]
+
+      data = Mathtype::Equation.read(eq).snapshot
+      @builder = Nokogiri::XML::Builder.new do |xml|
+        @xml = xml
+        xml.root do
+          process(object: data)
+        end
+      end
+    end
+
+    def to_xml
+      @builder.to_xml
+    end
+
+    def process(element: "mtef", object:)
+      if object.is_a? Hash
+        name = Mathtype::RECORD_NAMES[object[:record_type]]
+        if name
+          xml.send(name) do
+            (object[:payload] || {}).each do |k, v|
+              process(element: k, object: v)
+            end
+          end
+        else
+          xml.send(element) do
+            object.each do |k, v|
+              process(element: k, object: v)
+            end
+          end
+        end
+      elsif object.is_a? Array
+        object.each do |a|
+          process(element: element, object: a)
+        end
+      else
+        process_final_element(element, object)
+      end
+    end
+
+    def process_final_element(element, object)
+      if object.is_a? Hash
+        xml.send(element, object)
+      else
+        xml.send(element) { xml.text object }
+      end
+    end
+  end
+end

data/lib/records/char.rb

@@ -0,0 +1,84 @@
+# CHAR record (2):
+# Consists of:
+# record type (2)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [typeface] typeface value (signed integer; see FONT_STYLE_DEF record below)
+# [character] character value (see below)
+# [embellishment list] if mtefOPT_CHAR_EMBELL is set (embellishments)
+# The character value itself is represented by one or more values. The presence or absence of these value is indicated by options and appear in this order:
+# 16-bit integer MTCode value present unless the mtefOPT_CHAR_ENC_NO_MTCODE option is set
+# 8-bit font position present if the mtefOPT_CHAR_ENC_CHAR_8 option is set
+# 16-bit integer font position  present if the mtefOPT_CHAR_ENC_CHAR_16 option is set
+# The MTCode value defines the character independent of its font. MTCode is a superset of Unicode and is described in MTCode Encoding Tables. The 8-bit and 16-bit font positions are mutually exclusive but may both be absent. This is the position of the character within its font. Some of the common font encodings are given in Font Encoding Tables.
+
+require_relative "snapshot"
+
+module Mathtype
+  class RecordEmbell < BinData::Record; end
+  class RecordChar < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(nudge typeface mt_code_value options font_position
+      variation embellishment_list)
+
+    endian :little
+    int8 :options
+
+    nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_typeface
+
+    int16 :_mt_code_value, onlyif: (lambda do
+      options & OPTIONS["mtefOPT_CHAR_ENC_NO_MTCODE"] == 0
+    end)
+
+    font_position_choice = lambda do
+      char_enc_char_8 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_8"] > 0
+      char_enc_char_16 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_16"] > 0
+
+      if char_enc_char_8
+        8
+      elsif char_enc_char_16
+        16
+      end
+    end
+
+    font_position_present = lambda do
+      char_enc_char_8 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_8"] > 0
+      char_enc_char_16 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_16"] > 0
+
+      return true if char_enc_char_8 || char_enc_char_16
+    end
+
+    choice :font_position,
+        selection: font_position_choice,
+        onlyif: font_position_present do
+
+      uint8 8
+      uint16 16
+    end
+
+    array :embellishment_list,
+        onlyif: lambda { options & OPTIONS["mtefOPT_CHAR_EMBELL"] > 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def mt_code_value
+      sprintf("0x%04X", _mt_code_value)
+    end
+
+    def typeface
+      _typeface + 128
+    end
+
+    def variation
+      case typeface
+      when 8
+        "mathmode"
+      when 1
+        "textmode"
+      end
+    end
+  end
+end

data/lib/records/color.rb

@@ -0,0 +1,13 @@
+# COLOR records (15):
+# Consists of:
+# record type (15)
+# [color_def_index] index of corresponding COLOR_DEF record (unsigned integer)
+# The appearance of this record in the stream indicates that all following
+# equation records (until the next COLOR record) have the color defined by the
+# indicated COLOR_DEF record.
+
+module Mathtype
+  class RecordColor < BinData::Record
+    int8 :color_def_index
+  end
+end

data/lib/records/color_def.rb

@@ -0,0 +1,37 @@
+# COLOR_DEF records (16):
+# Consists of:
+# record type (16)
+# [options] model is RGB unless mtefCOLOR_CMYK bit is set; type is process
+# unless mtefCOLOR_SPOT bit is set; color is unnamed unless mtefCOLOR_NAME bit is set
+# [color values] if RGB, 3 values (red, green, blue); if CMYK, 4 values (cyan,
+# magenta, yellow, black); see below for details
+# [name] null-terminated color name appears only if mtefCOLOR_NAME is set
+# This record defines a color (see Definition records). Each color value is
+# written as a 16-bit integer that ranges between 0 and 1000 where 0 is the
+# absence of the color and 1000 is a fully saturated color. So, an RGB color
+# definition for black has all three components at 0.
+
+module Mathtype
+  class RecordColorDef < BinData::Record
+    endian :little
+
+    int8 :options
+
+    struct :rgb, onlyif: lambda { options & OPTIONS["mtefCOLOR_CMYK"] == 0 } do
+      int16 :r
+      int16 :g
+      int16 :b
+    end
+
+    struct :cmyk, onlyif: lambda { options & OPTIONS["mtefCOLOR_CMYK"] > 0} do
+      int16 :c
+      int16 :m
+      int16 :y
+      int16 :k
+    end
+
+    stringz :color_name, onlyif: (lambda do
+      options & OPTIONS["mtefCOLOR_NAME"] > 0
+    end)
+  end
+end

data/lib/records/embell.rb

@@ -0,0 +1,103 @@
+require_relative "snapshot"
+
+# EMBELL record (6):
+# Consists of:
+# record type (6)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [embell] embellishment type
+# The embellishment types are:
+
+# value symbol  description
+# 2 emb1DOT over single dot
+# 3 emb2DOT over double dot
+# 4 emb3DOT over triple dot
+# 5 emb1PRIME single prime
+# 6 emb2PRIME double prime
+# 7 embBPRIME backwards prime (left of character)
+# 8 embTILDE  tilde
+# 9 embHAT  hat (circumflex)
+# 10  embNOT  diagonal slash through character
+# 11  embRARROW over right arrow
+# 12  embLARROW over left arrow
+# 13  embBARROW over both arrow (left and right)
+# 14  embR1ARROW  over right single-barbed arrow
+# 15  embL1ARROW  over left single-barbed arrow
+# 16  embMBAR mid-height horizontal bar
+# 17  embOBAR over-bar
+# 18  emb3PRIME triple prime
+# 19  embFROWN  over-arc, concave downward
+# 20  embSMILE  over-arc, concave upward
+# 21  embX_BARS double diagonal bars
+# 22  embUP_BAR bottom-left to top-right diagonal bar
+# 23  embDOWN_BAR top-left to bottom-right diagonal bar
+# 24  emb4DOT over quad dot
+# 25  embU_1DOT under single dot
+# 26  embU_2DOT under double dot
+# 27  embU_3DOT under triple dot
+# 28  embU_4DOT under quad dot
+# 29  embU_BAR  under bar
+# 30  embU_TILDE  under tilde (~)
+# 31  embU_FROWN  under arc (ends point down)
+# 32  embU_SMILE  under arc (ends point up)
+# 33  embU_RARROW under right arrow
+# 34  embU_LARROW under left arrow
+# 35  embU_BARROW under both arrow (left and right)
+# 36  embU_R1ARROW  under right arrow (1 barb)
+# 37  embU_L1ARROW  under left arrow (1 barb)
+
+module Mathtype
+  class RecordEmbell < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge embell)
+
+    EMBELL = {
+      2 => "emb1DOT", # over single dot
+      3 => "emb2DOT", # over double dot
+      4 => "emb3DOT", # over triple dot
+      5 => "emb1PRIME", # single prime
+      6 => "emb2PRIME", # double prime
+      7 => "embBPRIME", # backwards prime (left of character)
+      8 => "embTILDE", #  tilde
+      9 => "embHAT", #  hat (circumflex)
+      10 => "embNOT", #  diagonal slash through character
+      11 => "embRARROW", # over right arrow
+      12 => "embLARROW", # over left arrow
+      13 => "embBARROW", # over both arrow (left and right)
+      14 => "embR1ARROW", #  over right single-barbed arrow
+      15 => "embL1ARROW", #  over left single-barbed arrow
+      16 => "embMBAR", # mid-height horizontal bar
+      17 => "embOBAR", # over-bar
+      18 => "emb3PRIME", # triple prime
+      19 => "embFROWN", #  over-arc, concave downward
+      20 => "embSMILE", #  over-arc, concave upward
+      21 => "embX_BARS", # double diagonal bars
+      22 => "embUP_BAR", # bottom-left to top-right diagonal bar
+      23 => "embDOWN_BAR", # top-left to bottom-right diagonal bar
+      24 => "emb4DOT", # over quad dot
+      25 => "embU_1DOT", # under single dot
+      26 => "embU_2DOT", # under double dot
+      27 => "embU_3DOT", # under triple dot
+      28 => "embU_4DOT", # under quad dot
+      29 => "embU_BAR", #  under bar
+      30 => "embU_TILDE", #  under tilde (~)
+      31 => "embU_FROWN", #  under arc (ends point down)
+      32 => "embU_SMILE", #  under arc (ends point up)
+      33 => "embU_RARROW", # under right arrow
+      34 => "embU_LARROW", # under left arrow
+      35 => "embU_BARROW", # under both arrow (left and right)
+      36 => "embU_R1ARROW", #  under right arrow (1 barb)
+      37 => "embU_L1ARROW", #  under left arrow (1 barb)
+    }
+
+    int8 :options
+
+    nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_embell
+
+    def embell
+      EMBELL[_embell]
+    end
+  end
+end

data/lib/records/encoding_def.rb

@@ -0,0 +1,22 @@
+# ENCODING_DEF records (19):
+# Consists of:
+# record type (19)
+# [name] null-terminated encoding name
+# This record defines (see Definition records) a font encoding and is referred
+# to by a FONT_DEF record. In order to reduce the size of the MTEF stream,
+# the following 4 encodings are predefined:
+
+# ENCODING_DEF index  encoding name
+# 1 MTCode
+# 2 Unknown
+# 3 Symbol
+# 4 MTExtra
+# This means that the first ENCODING_DEF record in the MTEF stream is considered
+# to have an index of 5. See Extending MathType's Font and Character Information
+# and MathType's Character Encodings for more information on font encodings.
+
+module Mathtype
+  class RecordEncodingDef < BinData::Record
+    stringz :name
+  end
+end

data/lib/records/end.rb

@@ -0,0 +1,8 @@
+module Mathtype
+  class RecordEnd < BinData::Primitive
+    def get; ""; end
+    def set(v); end
+
+    def to_formatted_s(indent = 0); to_s; end
+  end
+end

data/lib/records/eqn_prefs.rb

@@ -0,0 +1,44 @@
+# EQN_PREFS records (18):
+
+# Consists of:
+
+# record type (18)
+# [options] none defined in this version of MTEF
+# [sizes] dimension array for typesize definitions
+# [spaces] dimension array for spacing definitions (see below)
+# [styles] array of style definitions (see below)
+# When reading arrays, the number of values may be less than or greater than
+# expected. MTEF readers should be driven by the array count.
+# If the array is shorter than expected, assume defaults for the missing values.
+# If the array is longer than expected, the extra values must be skipped to stay
+# in sync with the MTEF stream.
+
+module Mathtype
+  class Entry < BinData::Record
+    bit4 :unit
+    array :nibbles, read_until: lambda { element == 0xF } do
+      bit4
+    end
+    resume_byte_alignment
+  end
+
+  class RecordEqnPrefs < BinData::Record
+    int8 :options
+
+    int8 :sizes_count
+    array :sizes, initial_length: :sizes_count do
+      entry
+    end
+
+    int8 :spaces_count
+    array :spaces, initial_length: :spaces_count do
+      entry
+    end
+
+    int8 :styles_count
+    array :styles, initial_length: :styles_count do
+      int8 :font_def
+      int8 :font_style, onlyif: lambda { font_def != 0x00 }
+    end
+  end
+end

data/lib/records/font_def.rb

@@ -0,0 +1,14 @@
+# FONT_DEF records (17):
+# Consists of:
+# record type (17)
+# [enc_def_index] index of corresponding ENCODING_DEF record (unsigned integer)
+# [name] null-terminated font name
+# This record associates an font encoding with a font name. See Definition
+# records.
+
+module Mathtype
+  class RecordFontDef < BinData::Record
+    uint8 :enc_def_index
+    stringz :font_name
+  end
+end

data/lib/records/font_style_def.rb

@@ -0,0 +1,14 @@
+# FONT_STYLE_DEF record (8):
+# Consists of:
+# record type (8)
+# [font_def_index] index of mtefFONT_DEF record (unsigned integer)
+# [char_style] character style bits
+# This record associates a character style with a font. See Definition records.
+
+module Mathtype
+  class RecordFontStyleDef < BinData::Record
+    uint8 :font_def_index
+
+    int8 :char_style
+  end
+end

data/lib/records/future.rb

@@ -0,0 +1,14 @@
+# If the record type is 100 or greater, it represents a record that will be
+# defined in a future version of MTEF. For now, readers can assume that an
+# unsigned integer follows the record type and is the number of bytes following
+# it in the record (i.e. it doesn't include the record type and length). This
+# makes it easy for software that reads MTEF to skip these records. Although it
+# might be handy if all records had such a length value, it will only be present
+# on future expansion records (i.e. those with record types >= 100).
+
+module Mathtype
+  class RecordFuture < BinData::Record
+    uint8 :skip
+    skip length: :skip
+  end
+end

data/lib/records/line.rb

@@ -0,0 +1,36 @@
+# LINE record (1):
+# Consists of:
+# record type (1)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [line spacing] if mtefOPT_LINE_LSPACE is set (16-bit integer)
+# [RULER record] if mtefOPT_LP_RULER is set
+# object list of line (single pile, characters and templates, or nothing)
+# The line spacing value, if present, is the distance between the baseline of
+# this line and the line above it.
+
+module Mathtype
+  class NamedRecord < BinData::Record; end
+  class RecordLine < BinData::Record
+    endian :little
+    int8 :options
+
+    nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int16 :line_spacing, onlyif: (lambda do
+      options & OPTIONS["mtefOPT_LINE_LSPACE"] > 0
+    end)
+
+    record_ruler :ruler, onlyif: (lambda do
+      options & OPTIONS["mtefOPT_LP_RULER"] > 0
+    end)
+
+    array :object_list,
+        onlyif: lambda { options & OPTIONS["mtefOPT_LINE_NULL"] == 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def to_formatted_s(indent = 0); to_s; end
+  end
+end

data/lib/records/matrix.rb

@@ -0,0 +1,41 @@
+# PILE record (4):
+# Consists of:
+# record type (4)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [halign] horizontal alignment
+# [valign] vertical alignment
+# [[RULER record]] if mtefOPT_LP_RULER is set
+# [object list] list of lines contained by the pile
+
+# The row partition line type list consists of two-bit values for each possible
+# partition line (one more than the number of rows), rounded out to the nearest
+# byte. Each value determines the line style of the corresponding partition line
+# (0 for none, 1 for solid, 2 for dashed, or 3 for dotted). Similarly for the
+# column partition lines.
+
+module Mathtype
+  class RecordMatrix < BinData::Record
+    int8 :options
+
+    nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :valign
+    int8 :h_just
+    int8 :v_just
+    int8 :rows
+    int8 :cols
+
+    array :row_parts, initial_length: lambda { rows + 1 } do
+      bit nbits: 2
+    end
+
+    array :col_parts, initial_length: lambda { cols + 1 } do
+      bit nbits: 2
+    end
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+  end
+end