mathtype_to_mathml_plus 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61dc01300451c4b4e4f50e41d021d3f5293fb5c8b49c3c839fec068f4801e8d9
-  data.tar.gz: 7dc1af9c3dffe93fe102540692a26829bcecafebe6f56277831f103c5df0127d
+  metadata.gz: fc4579dd069903f70cc783ad324cfc1c01a09573b07a334e0b5892a7087fcdb2
+  data.tar.gz: 4fc036e1f2bd673c07eaca8c2693645894b500e543ca885e4dcd5fbb6eb8e890
 SHA512:
-  metadata.gz: 98aff52b51c1a132f6e39e6aff9b63f9f6a9c1c97faf30f38fb9549413d8a5af3e74c7edc96b903f62ea2bee8902c15e2e0d251e9d6c4578e95a0a46a422fdb8
-  data.tar.gz: 8e0473bf44c72f733b26433b11959dfa0ed5021732cce538ffe1133df9d89f7fb189a48be33d6aaf549e2ea3398bde2ede38193d21fa4c7e77dab0891b12e98b
+  metadata.gz: b04c47298c11e02caccdb240cda47cadf566bc1b1d125f6d24de712a2e20002bd382aa55c601be5538d1ababa7f1e4075374b58055388f6afa35786b43a5ff21
+  data.tar.gz: da962421affc24aec5f71b1ea57df6a8a46d7446890e204a5a5fdf121fb8d8c1dc7ac1c016902e46b33515637a10f5a2ebe9dc70a79dd3dc22bb6746547c2ffb

data/convert.rb

@@ -1,6 +1,6 @@
 require_relative 'lib/mathtype_to_mathml_plus'
  
-converter = MathTypeToMathMLPlus::Converter.new("oleObject2.bin")
+converter = MathTypeToMathMLPlus::Converter.new("oleObject1.bin")
 xml = converter.convert
 
 puts xml

data/lib/mathtype-0.0.7.5/.gitignore

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

data/lib/mathtype-0.0.7.5/.rspec

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

data/lib/mathtype-0.0.7.5/Gemfile

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

data/lib/mathtype-0.0.7.5/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/lib/mathtype-0.0.7.5/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/lib/mathtype-0.0.7.5/Rakefile

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

data/lib/mathtype-0.0.7.5/lib/file_parser/eps.rb

@@ -0,0 +1,30 @@
+module Mathtype
+  class EpsFileParser < FileParser
+    def initialize(path)
+      super(path)
+      extract_mtef_from_epscomment(@raw)
+    end
+
+    def extract_mtef_from_epscomment(comment)
+      string64 = @raw.gsub /\r/, ""
+      # d for delimiter
+      d = string64[(/MathType(.)MTEF\1/ =~ string64) + 8]
+      matches = string64.match /.*MathType#{d}MTEF#{d}(.)#{d}(.)#{d}(.)(.)(.*)#{d}([0-9A-F]{4})#{d}.*/m
+      leading_chrs = matches[1].to_i
+      trailing_chrs = matches[2].to_i - 1
+      a64_chr1 = matches[3]
+      a64_chr2 = matches[4]
+      A64[a64_chr1] = 62
+      A64[a64_chr2] = 63
+      A64[62] = a64_chr1
+      A64[63] = a64_chr2
+      string64   = matches[5]
+      mtchecksum = matches[6]
+      string64.gsub! /.{#{trailing_chrs}}(\n).{#{leading_chrs}}/m, ""
+      @equation = decode string64
+      unless checksum == mtchecksum
+        raise ArgumentError, "Checksums do not match, expected #{mtchecksum} but got #{checksum}"
+      end
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/lib/file_parser/ole.rb

@@ -0,0 +1,15 @@
+require "bindata"
+require "ole/storage"
+
+module Mathtype
+  class OleFileParser < FileParser
+    def initialize(path)
+      read_from_file(path)
+    end
+    def read_from_file(path)
+      ole = Ole::Storage.open(path, "rb+")
+      @equation = ole.file.read("Equation Native")[28..-1]
+      ole.close
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/lib/file_parser/parser.rb

@@ -0,0 +1,102 @@
+module Mathtype
+  class FileParser
+    attr_reader :raw
+    attr_reader :equation
+    def initialize(path)
+      read_from_file(path)
+    end
+
+    def checksum
+      (@equation.bytes.reduce(:+) & 0xFFFF).to_s(16).upcase
+    end
+
+    def read_from_file(path)
+      f = File.open(path, "rb")
+      @raw = f.read
+      f.close
+    end
+
+    A64 =
+      {
+        "a" => 0, "b" => 1, "c" => 2, "d" => 3, "e" => 4,
+        "f" => 5, "g" => 6, "h" => 7, "i" => 8, "j" => 9,
+        "k" => 10, "l" => 11, "m" => 12, "n" => 13, "o" => 14, "p" => 15,
+        "q" => 16, "r" => 17, "s" => 18, "t" => 19, "u" => 20, "v" => 21,
+        "w" => 22, "x" => 23, "y" => 24, "z" => 25, "A" => 26, "B" => 27,
+        "C" => 28, "D" => 29, "E" => 30, "F" => 31, "G" => 32, "H" => 33,
+        "I" => 34, "J" => 35, "K" => 36, "L" => 37, "M" => 38, "N" => 39,
+        "O" => 40, "P" => 41, "Q" => 42, "R" => 43, "S" => 44, "T" => 45,
+        "U" => 46, "V" => 47, "W" => 48, "X" => 49, "Y" => 50, "Z" => 51,
+        "0" => 52, "1" => 53, "2" => 54, "3" => 55, "4" => 56, "5" => 57,
+        "6" => 58, "7" => 59, "8" => 60, "9" => 61, "+" => 62, "-" => 63,
+        0 => "a", 1 => "b", 2 => "c", 3 => "d", 4 => "e",
+        5 => "f", 6 => "g", 7 => "h", 8 => "i", 9 => "j",
+        10 => "k", 11 => "l", 12 => "m", 13 => "n", 14 => "o", 15 => "p",
+        16 => "q", 17 => "r", 18 => "s", 19 => "t", 20 => "u", 21 => "v",
+        22 => "w", 23 => "x", 24 => "y", 25 => "z", 26 => "A", 27 => "B",
+        28 => "C", 29 => "D", 30 => "E", 31 => "F", 32 => "G", 33 => "H",
+        34 => "I", 35 => "J", 36 => "K", 37 => "L", 38 => "M", 39 => "N",
+        40 => "O", 41 => "P", 42 => "Q", 43 => "R", 44 => "S", 45 => "T",
+        46 => "U", 47 => "V", 48 => "W", 49 => "X", 50 => "Y", 51 => "Z",
+        52 => "0", 53 => "1", 54 => "2", 55 => "3", 56 => "4", 57 => "5",
+        58 => "6", 59 => "7", 60 => "8", 61 => "9", 62 => "+", 63 => "-"
+      }
+
+    def decode(string64)
+      #decode from base64 mtef to binary mtef
+      l = string64.length
+      i = b0 = b1 = carry = 0
+      out = []
+      while i < l
+        chr  = A64[string64[i]]
+        case i % 4
+        when 0
+          b0  = chr
+          b1 = 0
+        when 1
+          b0 += ((chr & 3) << 6)
+          b1    = ((chr & 0xfc) >> 2)
+          out   << b0
+        when 2
+          b0  = ((chr & 0x30) >> 4)
+          b1   += ((chr & 0xf) << 4)
+        when 3
+          b0 += chr << 2
+          out << b1 << b0
+          b0=b1=0
+        end
+        i += 1
+      end
+      out << b0 if i % 2 == 1
+      return out.pack("C*")
+    end
+
+    def encode(mtef)
+      #encode from binary mtef to base64 mtef
+      out = ""
+      bytes = mtef.bytes
+      i = shft = 0
+      l = bytes.length
+      carry = 0
+      while i < l
+        chr = bytes[i] << shft
+        chr = chr | carry
+        out << A64[chr & 0x3f]
+        carry = chr >> 6
+        i += 1
+        shft = (i % 3) * 2
+        if shft == 0
+          out << A64[carry]
+          carry = 0
+        end
+      end
+      return out
+    end
+  end
+end
+
+
+require_relative "ole.rb"
+require_relative "wmf.rb"
+require_relative "eps.rb"
+

data/lib/mathtype-0.0.7.5/lib/file_parser/wmf.rb

@@ -0,0 +1,28 @@
+module Mathtype
+  class WmfFileParser < FileParser
+    def initialize(path)
+      super(path)
+      extract_mtef_from_mfcomment(@raw)
+    end
+
+    def extract_mtef_from_mfcomment(comment)
+      match = comment.match("MathTypeUU")
+      if match
+        lenpos = match.end(0)
+        len = comment[lenpos..lenpos+1].unpack("H*")[0].to_i 16
+        start = lenpos + 2
+      else
+        match = comment.match("AppsMFCC\x01")
+        raise ::NotImplementedError, "No MathType Equation found in wmf" unless match
+        len_start = match.end(0)
+        totallen = comment[len_start..len_start + 3].reverse.chars.rotate(-1).join.unpack("H*")[0].to_i 16
+        datalen = comment[len_start + 4 .. len_start + 7].reverse.chars.rotate(-1).join.unpack("H*")[0].to_i 16
+        signature = comment[len_start + 8.. -1].match(/.+?\x00/)
+        raise ::NotImplementedError, "Equation split over multiple comments" unless totallen == datalen
+        start = len_start + 8 + signature.end(0)
+        len = datalen
+      end
+      @equation = comment[start..(start + len)]
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/lib/mathtype/version.rb

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

data/lib/mathtype-0.0.7.5/lib/mathtype.rb

@@ -0,0 +1,86 @@
+require "mathtype/version"
+require "nokogiri"
+require_relative "file_parser/parser.rb"
+require_relative "records/mtef.rb"
+require_relative "records3/mtef.rb"
+require_relative "records5/mtef.rb"
+
+
+module Mathtype
+  class Converter
+    attr_reader :parser
+    attr_reader :xml
+    attr_reader :builder
+    attr_reader :version
+    def initialize(equation)
+      set_parser(equation)
+      raise ::NotImplementedError, "Equation format not supported. Only .eps, .wmf and .bin (OLE-Object) currently supported, supplied was: #{equation}" unless @parser.equation
+      @version = @parser.equation[0].unpack('C')[0].to_i
+      raise ::NotImplementedError, "Only MTEF Version 3 and 5 currently supported, version is #{version}" unless (version==3 or version==5)
+      case @version
+      when 3
+        data = Mathtype3::Equation.read(@parser.equation).snapshot
+      when 5
+        data = Mathtype5::Equation.read(@parser.equation).snapshot
+      end
+      @builder = Nokogiri::XML::Builder.new do |xml|
+        @xml = xml
+        xml.root do
+          process(object: data)
+        end
+      end
+    end
+
+    def set_parser(equation)
+      if equation.end_with?(".bin")
+        @parser = Mathtype::OleFileParser.new equation
+      elsif equation.end_with?(".wmf")
+        @parser = Mathtype::WmfFileParser.new equation
+      else
+        @parser = Mathtype::EpsFileParser.new equation
+      end
+    end
+
+    def to_xml
+      @builder.to_xml
+    end
+
+    def process(element: "mtef", object:)
+      if object.is_a? Hash
+        case @version
+        when 3
+          name = Mathtype3::RECORD_NAMES[object[:record_type]]
+        else
+          name = Mathtype5::RECORD_NAMES[object[:record_type]]
+        end
+        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/mathtype-0.0.7.5/lib/records/bintypes.rb

@@ -0,0 +1,37 @@
+module Mathtype
+  class Mtef16 < BinData::Primitive
+    uint8 :low, :initial_value => 0
+    uint8 :high, :initial_value => 0
+
+    def get; (high << 8) + low end
+    def getlow
+      self.low
+    end
+    def gethigh
+      self.high
+    end
+    def set(v)
+      self.low = v & 0xFF
+      self.high = (v & 0xFF00) >> 8
+    end
+  end
+
+  class MatrixLineByte < BinData::Primitive
+    # row/columlines are represented as 2-bit values in a full byte, in reverse
+    # see MATRIX RECORD (5)
+    # a 3x3 matrix with rows "solid none dashed solid" would be represented as
+    # 01 10 00 01 = reverse      01   00     10    01
+    # a 4x4 matrix with "solid none dashed solid solid         " accordingly does
+    # 01100001 00000001 =   01   00     10    01    01 00 00 00
+    uint8 :_byte
+
+    def get
+      [
+        (self._byte & 0x03),
+        (self._byte & 0x0C) >> 2,
+        (self._byte & 0x30) >> 4,
+        (self._byte & 0xC0) >> 6
+      ]
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/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/mathtype-0.0.7.5/lib/records/mtef.rb

@@ -0,0 +1,36 @@
+require_relative 'snapshot'
+require_relative 'bintypes'
+require_relative 'end'
+require_relative 'nudge'
+require_relative 'ruler'
+require_relative 'typesizes'
+
+module Mathtype
+
+  HALIGN = {
+    1 => "left",
+    2 => "center",
+    3 => "right",
+    4 => "al", # relational
+    5 => "dec" # decimal
+  }
+
+  VALIGN = {
+    0 => "top_baseline",
+    1 => "center_baseline",
+    2 => "bottom_baseline",
+    3 => "center", # vertical centering
+    4 => "axis" # math axis (center of +,-, brace points, etc.)
+  }
+
+  class Equation < BinData::Record
+    endian :little
+    uint8 :mtef_version
+    uint8 :platform
+    uint8 :product
+    uint8 :product_version
+    uint8 :product_subversion
+    include Snapshot
+  end
+
+end

data/lib/mathtype-0.0.7.5/lib/records/nudge.rb

@@ -0,0 +1,38 @@
+# Nudge values:
+# LINE, CHAR, TMPL, PILE, MATRIX, and EMBELL records may store the result of
+# nudging (small offsets applied by the user). A nudged record has the
+# mtefOPT_NUDGE option (0x8) and the option byte is followed immediately by
+# the nudge offset. The nudge offset consists of either two bytes or six,
+# depending on the amount of offset. If -128 <= dx < +128 and
+# -128 <= dy < +128, then the offsets are stored as two bytes, dx followed
+# by dy, where each value has 128 added to it before it is written. Otherwise,
+# two bytes of 128 are stored, followed by the offsets, dx and dy, stored as
+# 16-bit values, low byte followed by high byte.
+
+require_relative "snapshot"
+
+module Mathtype
+  class RecordNudge < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(dx dy)
+
+    endian :little
+
+    int8 :_small_dx
+    int8 :_small_dy
+    mtef16 :_large_dx, :onlyif => lambda { has_large_offset }
+    mtef16 :_large_dy, :onlyif => lambda { has_large_offset }
+
+    def dx
+      has_large_offset ? _large_dx : (_small_dx - 128)
+    end
+
+    def dy
+      has_large_offset ? _large_dy : (_small_dy - 128)
+    end
+
+    def has_large_offset
+      _small_dx == -128 and _small_dy == -128
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/lib/records/ruler.rb

@@ -0,0 +1,22 @@
+# RULER record (7):
+# Consists of:
+# record type (7)
+# [n_stops] number of tab-stops
+# [tab-stop list] tab-stops in order from left-to-right
+# Each tab stop is described by a tab-stop type
+# (0 for left, 1 for center, 2 for right, 3 for equal, 4 for decimal),
+# followed by a 16-bit integer offset from the left end of the slot or pile
+# with which it is associated.
+
+module Mathtype
+  class RecordRuler < BinData::Record
+    endian :little
+
+    int8 :n_stops
+
+    array :tab_stops, initial_length: :n_stops do
+      int8 :tab_stop_type
+      mtef16 :tab_stop
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/lib/records/snapshot.rb

@@ -0,0 +1,19 @@
+require "bindata"
+
+module Mathtype
+  module Snapshot
+    def snapshot
+      snapshot = BinData::Record::Snapshot.new
+      exposed = self.class.const_get(:EXPOSED_IN_SNAPSHOT)
+      exposed.each do |name|
+        obj = find_obj_for_name(name)
+        if obj
+          snapshot[name] = obj.snapshot if include_obj?(obj)
+        else
+          snapshot[name] = self.send(name)
+        end
+      end
+      snapshot
+    end
+  end
+end

data/lib/mathtype-0.0.7.5/lib/records/tmp.rb

@@ -0,0 +1,7 @@
+module Mathtype
+  class RecordChar < BinData::Record; end
+  class RecordLine < BinData::Record; end
+  class RecordMatrix < BinData::Record; end
+  class RecordPile < BinData::Record; end
+  class RecordSize < BinData::Record; end
+end

data/lib/mathtype-0.0.7.5/lib/records/typesizes.rb

@@ -0,0 +1,19 @@
+# Typesize records (10-14):
+# Consists of:
+# record type (10-14)
+# These records are just short ways of specifying a simple typesize where dsize
+# is zero. The tag value represents an lsize + 10. So if the tag value is 10,
+# it means equation content following it will be Full size (szFULL), tag value
+# 11 means szSUB, and so on. See typesize.
+
+module Mathtype
+  class RecordFull < BinData::Record; end
+
+  class RecordSub < BinData::Record; end
+
+  class RecordSub2 < BinData::Record; end
+
+  class RecordSym < BinData::Record; end
+
+  class RecordSubsym < BinData::Record; end
+end

data/lib/mathtype-0.0.7.5/lib/records3/char.rb

@@ -0,0 +1,53 @@
+# 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 Mathtype3
+  class RecordEmbell < BinData::Record; end
+  class RecordChar < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge typeface mt_code_value embellishment_list)
+
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_typeface
+
+    mtef16 :_mt_code_value
+
+    array :embellishment_list,
+        onlyif: lambda { _options & OPTIONS["xfEMBELL"] > 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 options
+      _tag_options
+    end
+  end
+end