mathtype_to_mathml_plus 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0d7a2cafb7ebf7215d919139933493434e2adbb28eef0e1b5454147246217fe
+  data.tar.gz: 7171abda1cc4e10bd2d3183e00885048eaee2e39d0a3640b29e74b01e0e50608
+SHA512:
+  metadata.gz: ddc97e1f19c6db5e1112d875270a40c2d26954b7d393c7f65bfbbc860fe2863c0dcb7e151135878c25a59aaded99ae437b364403b257baad18cf5e0b5c85da2e
+  data.tar.gz: 3e44ee439201b4da295c4bf106a86b8de494b0dae91723fa9f62c78c5450f2ec2368ece0551fd0cd879d6c87becc64349fb029ac04737b8e42f4a6fe09cef8dc

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 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,6 @@
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mathtype_to_mathml.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,45 @@
+# MathTypeToMathML
+
+This gem can be used to convert MathType equations from a binary format (e.g. embedded in Word documents) to an open MathML representation. It achieves that in several stages, first using the [`mathtype`](https://github.com/jure/mathtype) gem to convert from a binary to an XML form of MTEF, and second, using XSLTs to convert XML to MathML.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mathtype_to_mathml'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mathtype_to_mathml
+
+## Usage
+
+To convert a MathType equation embedded in a Word document (the file is usually named something like `oleObject1.bin`):
+
+```
+mathml = MathTypeToMathML::Converter.new(`oleObject1.bin`).convert
+```
+
+This will return a MathML string of the MathType equation.
+
+# Testing
+
+Run `bundle exec rspec` to run specs. Additionally, you can create a visual output using `html_output.rb`, like so:
+
+```
+bundle exec ruby spec/html_output.rb > test.html
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/jure/mathtype_to_mathml/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,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/lib/mathtype_to_mathml/char_replacer.rb

@@ -0,0 +1,366 @@
+require "nokogiri"
+
+# XSLT 1.0 has virtually non-existent capabilities for character ranges,
+# codepoints, hex to decimal, etc., so we replace characters within character
+# ranges with Ruby. Additonally, it's not possible to get the actual character
+# represented by a hexadecimal number in XSLT, so we deal with those here too.
+# Regular single character translations are still done with XSLT (char.xsl).
+
+
+
+
+module MathTypeToMathML
+  class CharReplacer
+    UNSUPPORTED = "Unsupported (Char)"
+
+    DEFAULT_TEXTMODE = "(Char)"
+    DEFAULT_MATHMODE = "<mi>(Char)<mi>"
+
+    REPLACEMENTS = {
+      0x0021 => { # Exclamation mark
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x0028 => { # Left parenthesis
+        mathmode: "<mo stretchy='false'>(Char)</mo>"
+      },
+      0x0029 => { # Right parenthesis
+        mathmode: "<mo stretchy='false'>(Char)</mo>"
+      },
+      0x002A => { # Asterisk
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002B => { # Plus sign
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002C => { # Plus sign
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002D => { # Hyphen-minus
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002E => { # Full stop
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002F => { # Solidus
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x003D => { # Equals sign
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x003F => { # Question mark
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x005B => { # Left square bracket
+        mathmode: "<mo stretchy='false'>(Char)</mo>"
+      },
+      0x005D => { # Right square bracket
+        mathmode: "<mo stretchy='false'>(Char)</mo>"
+      },
+      0x007E => { # Tilda
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x0000..0x0008 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x000B..0x001F => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x0030..0x0039 => { # (range) DIGITS 0-9
+        mathmode: "<mn>(Char)</mn>",
+        number: "(Char)",
+        textmode: "(Char)"
+      },
+      0x003A..0x003B => { # (range) COLON, SEMICOLON
+        mathmode: "<mo>(Char)</mo>",
+        textmode: "(Char)"
+      },
+      0x0041..0x005A => { # range: Basic Latin
+        mathmode: "<mi>(Char)</mi>",
+        textmode: "(Char)"
+      },
+      0x0061..0x007A => { # range: Basic Latin
+        mathmode: "<mi>(Char)</mi>",
+        textmode: "(Char)"
+      },
+      0x0080..0x009F => { # range: C1 Controls
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x00A0..0x00B0 => { # range: Latin-1 Supplement
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x00B2..0x00BB => { # range: Latin-1 Supplement
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x00BC..0x00BE => { # range: Latin-1 Supplement
+        mathmode: "<mn>(CharHex)</mn>"
+      },
+      0x02C6..0x02FF => { # range: Spacing Modifier Letters
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x0300..0x036F => { # range: Combining Diacritical Marks
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2000..0x200B => { # range: Spaces
+        mathmode: "<mtext>(CharHex)</mtext>"
+      },
+      0x200C..0x200F => { # range: Formatting Characters
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x2010..0x2027 => { # range: General Punctuation
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2028..0x202F => { # range: Formatting Characters
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x2030..0x2069 => { # range: General Punctuation
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x206A..0x206F => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x2070..0x209F => { # range: Superscripts and Subscripts
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x20A0..0x20CF => { # range: Currency Symbols
+        mathmode: "<mi>(CharHex)</mi>"
+      },
+      0x20D0..0x20FF => { # range: Combining Diacritical Marks for Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2100..0x2101 => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2103..0x210A => { # range: CJK Symbols and Punctuation
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2116..0x2117 => { # range: Supplemental Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x213C..0x2146 => { # range: Miscellaneous Mathematical Symbols-B
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2150..0x218F => { # range: Miscellaneous Mathematical Symbols-B
+        mathmode: "<mn>(CharHex)</mn>"
+      },
+      0x2190..0x21FF => { # range: Miscellaneous Mathematical Symbols-B
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2200..0x2211 => { # range: Supplemental Arrows-B
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2213..0x221D => { # range: Supplemental Arrows-A
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x221F..0x22FF => { # range: Dingbats
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2300..0x23FF => { # range: Miscellaneous Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2400..0x243F => { # range: Geometric Shapes
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2500..0x257F => { # range: Block Elements
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2580..0x259F => { # range: Box Drawing
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x25A0..0x25FF => { # range: Control Pictures
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2600..0x267F => { # range: Miscellaneous Technical
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2700..0x27BF => { # range: Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x27F0..0x27FF => { # range: Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2900..0x297F => { # range: Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2980..0x29AF => { # range: Arrows
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x29B1..0x29DB => { # range: Number Forms
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x29DD..0x29FF => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2A00..0x2AFF => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x3000..0x303F => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      # 0xE000..0xE900 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE905..0xE90A => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE90D..0xE921 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE926..0xE92C => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE92E..0xE931 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE934..0xE939 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE93C..0xE98E => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xE990..0xEA05 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEA08..0xEA0A => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEA0D..0xEA31 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEA36..0xEA39 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEA3C..0xEA3F => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEA46..0xEB00 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEB03..0xEB04 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEB07..0xED09 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xED14..0xED15 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xED17..0xEE03 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEE04..0xEE0C => {
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEE0D..0xEE18 => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEE1A..0xEEFF => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xEF09..0xEFFF => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF000..0xF033 => {
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF034..0xF07F => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF080..0xF0B3 => {
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF0B4..0xF0BF => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF0C0..0xF0C9 => {
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF0CA..0xF0FF => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF100..0xF133 => {
+      #   textmode: UNSUPPORTED
+      # },
+      # 0xF134..0xF8FF => {
+      #   mathmode: UNSUPPORTED,
+      #   textmode: UNSUPPORTED
+      # },
+      0xFB00..0xFB4F => { # range: Alphabetic Presentation Forms
+        mathmode: "<mtext>(CharHex)</mtext>"
+      },
+      0xFE35..0xFE4F => { # range: CJK Compatibility Forms
+        mathmode: "<mo>(CharHex)</mo>"
+      }
+    }
+
+    attr_accessor :mathtype
+
+    def initialize(mathtype)
+      @mathtype = mathtype
+    end
+
+    def replace
+      @mathtype.css("char").each do |char|
+        replacement = REPLACEMENTS.find do |range, _|
+          range === char.xpath("mt_code_value").text.hex
+        end
+        replace_character(replacement, char) if replacement
+      end
+
+      # Reparse XML to merge adjacent text nodes
+      @mathtype = Nokogiri::XML(@mathtype.to_xml)
+    end
+
+    def replace_character(replacement, char)
+      if char.xpath("variation = 'textmode'")
+        replacement = replacement[1][:textmode] || DEFAULT_TEXTMODE
+        xml = replacement_xml(replacement, char)
+      else
+        replacement = replacement[1][:mathmode] || DEFAULT_MATHMODE
+        xml = replacement_xml(replacement, char)
+      end
+
+      char.replace Nokogiri::HTML::DocumentFragment.parse(xml)
+    end
+
+    def replacement_xml(string, char)
+      string.gsub("(Char)") do
+        char.xpath("mt_code_value").text.hex.chr("UTF-8") # e.g. π
+      end.gsub("(CharHex)") do
+        "&#x#{char.xpath('mt_code_value').text[2..-1]};" # e.g. &#x2229;
+      end
+    end
+  end
+end
+
+
+
+

data/lib/mathtype_to_mathml/mover.rb

@@ -0,0 +1,151 @@
+require "nokogiri"
+
+# We're moving elements around to avoid "scanning" for characters when
+# using the /scan translator mode. The original issue is that MathType
+# considers subscripts and superscripts to be stand-alone, while MathML
+# considers them subscripts and superscripts of an object, and the object
+# is then included in the sub/superscript element.
+
+# MathType's translator has a scan mode, which does the following:
+# 1. Scanning goes to the right for commands with the "pre" option,
+#   otherwise left;
+# 2. If we are scanning right and the object next to the template is an
+#   opening "fence" character (parenthesis, bracket, brace, etc.),
+#   the slot is scanned for the corresponding closing fence character;
+# 3. If we are scanning left and the object next to the template is an closing
+#   "fence" character (parenthesis, bracket, brace, etc.), the slot is scanned
+#   for the corresponding opening fence character;
+# 4. If the fenced expression is found, it is used as #1 in the template translation.
+
+# Additionally, Mover inverts <emb>ellishments from <char><emb></emb></char> to
+# <emb><char></char></emb>.
+
+module MathTypeToMathML
+  class Mover
+    attr_reader :mathtype
+    attr_accessor :last_preceding_siblings
+
+    PARENS_SELECTOR = "selector='tmPARENS' or "\
+      "selector='tmBRACK' or " \
+      "selector='tmBRACE' or " \
+      "selector='tmOBRACK' or " \
+      "selector='tmOBRACE' or " \
+      "selector='tmHBRACK' or " \
+      "selector='tmHBRACE'"
+
+    SUBSUP_SELECTOR = "selector='tmSUP' or " \
+      "selector='tmSUB' or " \
+      "selector='tmSUBSUP'"
+
+    PRE = "variation='tvSU_PRECEDES'"
+
+    OPEN_PAREN = "mt_code_value = '0x0028' or " \
+      "mt_code_value = '0x005B' or " \
+      "mt_code_value = '0x007B'"
+
+    CLOSE_PAREN = "mt_code_value = '0x0029' or " \
+      "mt_code_value = '0x005D' or " \
+      "mt_code_value = '0x007D'"
+
+    OPEN_CLOSE_PAIRS = {
+      "0x0028" => "0x0029", # ( )
+      "0x005B" => "0x005D", # [ ]
+      "0x007B" => "0x007D", # { }
+    }
+
+    def initialize(mathtype)
+      @mathtype = mathtype
+      @last_preceding_siblings = Nokogiri::XML::NodeSet.new(@mathtype)
+    end
+
+    def move_until_mt_code(elements, mt_code_value, parent)
+      elements.each do |element|
+        element.parent = parent
+        break if element.xpath("mt_code_value = '#{mt_code_value}'")
+      end
+    end
+
+    def move_paren(siblings, node)
+      OPEN_CLOSE_PAIRS.each do |open, close|
+        if siblings[0].xpath("mt_code_value = '#{open}'") # ( )
+          move_until_mt_code(siblings, close, node)
+        end
+      end
+    end
+
+    def new_preceding_siblings(el)
+      all_siblings = el.xpath("preceding-sibling::tmpl | preceding-sibling::char")
+      siblings = all_siblings - last_preceding_siblings
+      self.last_preceding_siblings = all_siblings
+      siblings
+    end
+
+    def new_following_siblings(el)
+      el.xpath("following-sibling::tmpl | following-sibling::char")
+    end
+
+    def move_following_subsup
+      mathtype.xpath("//tmpl[(#{SUBSUP_SELECTOR}) and not(#{PRE})]").each do |el|
+        siblings = new_preceding_siblings(el)
+
+        node = Nokogiri::XML::Node.new "slot", mathtype
+
+        if siblings.last.xpath(CLOSE_PAREN)
+          siblings = siblings.reverse.take_while do |sibling|
+            !sibling.next_element.xpath(OPEN_PAREN)
+          end.reverse
+
+          move_paren(siblings, node)
+        elsif siblings.last.xpath("self::tmpl[#{PARENS_SELECTOR}]")
+          siblings.last.parent = node
+        else
+          siblings.last.parent = node
+        end
+
+        el.at_css("slot").add_previous_sibling node
+      end
+    end
+
+    def move_preceding_subsup
+      mathtype.xpath("//tmpl[(#{SUBSUP_SELECTOR}) and #{PRE}]").each do |el|
+        siblings = new_following_siblings(el)
+
+        node = Nokogiri::XML::Node.new "slot", mathtype
+
+        if siblings.first.xpath(OPEN_PAREN)
+          siblings = siblings.reverse.take_while do |sibling|
+            !sibling.next_element.xpath(CLOSE_PAREN)
+          end.reverse
+
+          move_paren(siblings, node)
+        elsif siblings.first.xpath("self::tmpl[#{PARENS_SELECTOR}]")
+          siblings.first.parent = node
+        else
+          siblings.first.parent = node
+        end
+
+        el.at_css("slot").add_previous_sibling node
+      end
+    end
+
+    def invert_char_embell
+      # Invert char -> embell to embell -> char.
+      mathtype.xpath("//char[embell]").each do |el|
+        embell = el.xpath("embell").first.remove
+        char = el.clone
+        char.parent = embell
+        el.replace(embell)
+      end
+    end
+
+    def move
+      move_following_subsup
+      move_preceding_subsup
+      invert_char_embell
+    end
+  end
+end
+
+
+
+

data/lib/mathtype_to_mathml/version.rb

@@ -0,0 +1,3 @@
+module MathTypeToMathML
+  VERSION = "0.0.8"
+end

data/lib/mathtype_to_mathml.rb

@@ -0,0 +1,45 @@
+require "mathtype_to_mathml/version"
+require "nokogiri"
+require "mathtype"
+require_relative "mathtype_to_mathml/mover"
+require_relative "mathtype_to_mathml/char_replacer"
+
+module MathTypeToMathML
+  class Converter
+    def initialize(mathtype)
+      @xslt = Nokogiri::XSLT(File.open(path_to_xslt))
+
+    converter = Mathtype::Converter.new(mathtype)
+    doc = converter.xml.doc
+
+      File.open("mathtype.log", "a") do |f|
+     f.puts "----- NEW LOG #{Time.now} -----"
+     f.puts doc.to_xml(indent: 2)
+    end
+
+      @mathtype = doc
+      # Addresses lack of scaning mode in our translator. See "Mover" for more.
+      mover = Mover.new(@mathtype)
+      mover.move
+
+      # Character ranges are tricky in XSLT 1.0, so we deal with them in Ruby
+      char_replacer = CharReplacer.new(@mathtype)
+      char_replacer.replace
+    end
+
+    def convert
+      out = @xslt.transform(@mathtype)
+      # This is a hack, but XML namespaces are such a pain to get
+      # right, especially in nokigiri, so... We assume all content is
+      # mathml, remove namespaces & set the root default namespace to
+      # mathml
+      out.remove_namespaces!
+      out.root.default_namespace = 'http://www.w3.org/1998/Math/MathML'
+      out.to_s
+    end
+
+    def path_to_xslt
+      File.join(File.dirname(File.expand_path(__FILE__)), "transform.xsl")
+    end
+  end
+end