mathematical 0.6.2 → 1.0.0

data/lib/mathematical.rb

@@ -1,8 +1,118 @@
 require 'mathematical/mathematical'
 
 require 'mathematical/corrections'
-require 'mathematical/render'
 require 'mathematical/version'
 
-module Mathematical
+require 'base64'
+
+class Mathematical
+  include Corrections
+
+  FORMAT_TYPES = [:svg, :png, :mathml]
+
+  DEFAULT_OPTS = {
+    :ppi => 72.0,
+    :zoom => 1.0,
+    :base64 => false,
+    :maxsize => 0,
+    :format => :svg
+  }
+
+  XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+
+  def initialize(opts = {})
+    @config = DEFAULT_OPTS.merge(opts)
+
+    validate_config
+
+    @config[:formatInt] = FORMAT_TYPES.index(@config[:format])
+
+    @processer = Mathematical::Process.new(@config)
+  end
+
+  def render(maths)
+    maths = validate_content(maths)
+
+    begin
+      data = @processer.process(maths)
+      fail RuntimeError if data.nil? || (!data.is_a?(Hash) && !data.is_a?(Array))
+
+      if data.is_a? Array
+        data.map { |d| format_data(d) }
+      else
+        format_data(data)
+      end
+    rescue ParseError, DocumentCreationError, DocumentReadError => e
+      # an error in the C code, probably a bad TeX parse
+      $stderr.puts "#{e.message}: #{maths}"
+      maths
+    end
+  end
+
+  def validate_content(maths)
+    if !maths.is_a?(String) && !maths.is_a?(Array)
+      fail(TypeError, 'input must be a string or an array!')
+    end
+
+    if maths.is_a? String
+      validate_string(maths)
+    else
+      validate_array(maths)
+    end
+  end
+
+  private
+
+  def validate_config
+    fail(TypeError, 'maxsize must be an integer!') unless @config[:maxsize].is_a? Fixnum
+    fail(TypeError, 'maxsize cannot be less than 0!') if @config[:maxsize] < 0
+    fail(TypeError, 'format must be a symbol!') unless @config[:format].is_a? Symbol
+    fail(TypeError, "format type must be one of the following formats: #{FORMAT_TYPES.join(', ')}") unless FORMAT_TYPES.include?(@config[:format])
+  end
+
+  def validate_string(maths)
+    maths = maths.strip
+    unless valid_math_string(maths)
+      fail(ArgumentError, 'input must be in tex format (`$...$` or `$$...$$`)!')
+    end
+
+    maths
+  end
+
+  def validate_array(maths)
+    unless maths.all? { |m| m.is_a?(String) }
+      fail(ArgumentError, 'every element in array must be a string in tex format (`$...$` or `$$...$$`)!')
+    end
+
+    maths = maths.map(&:strip)
+    unless maths.all? { |m| valid_math_string(m) }
+      fail(ArgumentError, 'every element in array must be a string in tex format (`$...$` or `$$...$$`)!')
+    end
+
+    maths
+  end
+
+  def valid_math_string(maths)
+    maths =~ /\A\${1,2}/
+  end
+
+  def format_data(data)
+    # we passed in an array of math, and found an unprocessable element
+    return data unless data.is_a? Hash
+
+    case @config[:format]
+    when :svg
+      # remove starting <?xml...> tag
+      data['svg'] = data['svg'][XML_HEADER.length..-1]
+      data['svg'] = svg_to_base64(data['svg']) if @config[:base64]
+
+      data
+    when :png, :mathml # do nothing with these...for now?
+      data
+    end
+  end
+
+  def svg_to_base64(contents)
+    "data:image/svg+xml;base64,#{Base64.strict_encode64(contents)}"
+  end
 end

data/lib/mathematical/corrections.rb

@@ -1,10 +1,10 @@
-module Mathematical
+class Mathematical
   module Corrections
     def apply_corrections(maths)
       adjust_lt_gt(maths)
     end
 
-    # from the itex website:
+    # from the itex website: http://bit.ly/1Et74ed
     # It is possible (though probably not recommended) to insert MathML markup
     # inside itex equations. So "<" and ">" are significant.
     # To obtain a less-than or greater-than sign, you should use \lt or \gt, respectively.

data/lib/mathematical/version.rb

@@ -1,3 +1,3 @@
-module Mathematical
-  VERSION = '0.6.2'
+class Mathematical
+  VERSION = '1.0.0'
 end

data/mathematical.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Mathematical::VERSION
   spec.authors       = ['Garen Torikian']
   spec.email         = ['gjtorikian@gmail.com']
-  spec.summary       = %q{Quickly convert math equations into beautiful SVGs/PNGs/MathML.}
-  spec.description   = %q{A very fast way to turn itex math equations into beautifully rendered SVGs, to embed on the web. This library is mostly written in C and is a general purpose wrapper to GNOME's Lasem. }
+  spec.summary       = %w(Quickly convert math equations into beautiful SVGs/PNGs/MathML.)
+  spec.description   = %w(A very fast way to turn LaTeX math equations into beautifully rendered SVGs, to embed on the web. This library is mostly written in C and is a general purpose wrapper to GNOME's Lasem.)
   spec.homepage      = 'https://github.com/gjtorikian/mathematical'
   spec.license       = 'MIT'
 
@@ -18,13 +18,13 @@ Gem::Specification.new do |spec|
   spec.files        += Dir.glob('ext/**/*.{c,h}')
   spec.files        += Dir.glob('ext/**/extconf.rb')
   spec.test_files    = Dir.glob('test/**/*')
-  spec.require_paths = ['lib', 'ext']
+  spec.require_paths = %w(lib ext)
   spec.extensions    = ['ext/mathematical/extconf.rb']
 
   spec.add_development_dependency 'rake', '~> 0.9'
   spec.add_development_dependency 'rake-compiler', '~> 0.9'
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'mocha', '~> 1.0'
-  spec.add_development_dependency 'math-to-itex', '~> 0.3'
+  spec.add_development_dependency 'math-to-itex', '0.3.0'
   spec.add_development_dependency 'nokogiri', '~> 1.6'
 end

data/test/mathematical/basic_test.rb

@@ -7,7 +7,7 @@ class Mathematical::BasicTest < Test::Unit::TestCase
   end
 
   def test_multiple_calls
-    render = Mathematical::Render.new
+    render = Mathematical.new
     render.render('$\pi$')
     output = render.render('$\pi$')['svg']
     assert_equal 1, output.scan(/<svg/).size, 'should only contain one svg'

data/test/mathematical/corrections_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 class Mathematical::CorrectionsTest < Test::Unit::TestCase
 
   def setup
-    @render = Mathematical::Render.new
+    @render = Mathematical.new
   end
 
   def test_adjust_lt_gt

data/test/mathematical/fixtures_test.rb

@@ -15,30 +15,30 @@ class Mathematical::FixturesTest < Test::Unit::TestCase
       if ENV['MATHEMATICAL_GENERATE_SAMPLE']
         next unless name.match /compliance/
         actual = MathToItex(source).convert do |eq, type|
-          svg_content = Mathematical::Render.new(:base64 => false).render(eq)
+          svg_content = Mathematical.new(:base64 => false).render(eq)
           # remove \ and $, remove whitespace, keep alphanums, remove extraneous - and trailing -
           filename = eq.gsub(/[\$\\]*/, '').gsub(/\s+/, '-').gsub(/[^a-zA-Z\d]/, '-').gsub(/-{2,}/, '-').gsub(/-$/, '')
-          File.open("samples/fixtures/#{filename}.svg", "w") { |file| file.write svg_content["svg"] }
+          File.open("samples/fixtures/#{filename}.svg", 'w') { |file| file.write svg_content['svg'] }
         end
       end
 
       actual = MathToItex(source).convert do |eq, type|
-        svg_content = Mathematical::Render.new(:base64 => true).render(eq)
+        svg_content = Mathematical.new(:base64 => true).render(eq)
 
         %|<img class="#{type.to_s}-math" data-math-type="#{type.to_s}-math" src="#{svg_content['svg']}"/>|
       end.rstrip
 
-      expected_file = before.sub(/before/, "after").sub(/text/, "html")
+      expected_file = before.sub(/before/, 'after').sub(/text/, 'html')
 
-      File.open(expected_file, "w") { |file| file.write(actual) } unless ENV['DEBUG_MATHEMATICAL'].nil?
+      File.open(expected_file, 'w') { |file| file.write(actual) } unless ENV['DEBUG_MATHEMATICAL'].nil?
 
       expected = File.read(expected_file)
 
-      expected = (MathToItex(expected).convert {|string| Mathematical::Render.new.render(string)}).rstrip
+      expected = (MathToItex(expected).convert {|string| Mathematical.new.render(string)}).rstrip
 
       # Travis and OS X each render SVGs differently. For now, let's just be happy
       # that something renders at all.
-      unless actual.match("PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My")
+      unless actual.match('PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My')
         diff = IO.popen("diff -u - #{expected_file}", 'r+') do |f|
           f.write actual
           f.close_write

data/test/mathematical/maliciousness_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 class Mathematical::MaliciousnessTest < Test::Unit::TestCase
 
   def test_it_does_not_error_on_unrecognized_commands
-    render = Mathematical::Render.new
+    render = Mathematical.new
     output = nil
     # In mtex2MML, we raise a ParseError, but Mathematical suppresses it and returns the string.
     assert_nothing_raised { output = render.render('$not__thisisnotreal$') }
@@ -13,77 +13,104 @@ class Mathematical::MaliciousnessTest < Test::Unit::TestCase
   def test_it_does_not_blow_up_on_bad_arguments
     # need to pass a hash here
     assert_raise TypeError do
-      render = Mathematical::Render.new("not a hash")
+      render = Mathematical.new("not a hash")
     end
 
     # need to pass a string here
-    render = Mathematical::Render.new
+    render = Mathematical.new
     assert_raise TypeError do
-      Mathematical::Render.new.render(123)
+      Mathematical.new.render(123)
     end
   end
 
   def test_it_does_not_blow_up_on_bad_options
     assert_raise TypeError do
-      render = Mathematical::Render.new({:ppi => "not a number"})
+      render = Mathematical.new({:ppi => "not a number"})
     end
 
     assert_raise TypeError do
-      render = Mathematical::Render.new({:zoom => "not a number"})
+      render = Mathematical.new({:zoom => "not a number"})
     end
 
     assert_raise TypeError do
-      render = Mathematical::Render.new({:maxsize => "not a number"})
+      render = Mathematical.new({:maxsize => "not a number"})
     end
 
     assert_raise TypeError do
-      render = Mathematical::Render.new({:maxsize => -23})
+      render = Mathematical.new({:maxsize => -23})
     end
 
     assert_raise TypeError do
-      render = Mathematical::Render.new({:maxsize => 5.3})
+      render = Mathematical.new({:maxsize => 5.3})
     end
 
     assert_raise TypeError do
-      render = Mathematical::Render.new({:format => 123})
+      render = Mathematical.new({:format => 123})
     end
 
     assert_raise TypeError do
-      render = Mathematical::Render.new({:format => "something amazing"})
+      render = Mathematical.new({:format => "something amazing"})
     end
 
     assert_raise Mathematical::MaxsizeError do
-      render = Mathematical::Render.new({:maxsize => 2})
+      render = Mathematical.new({:maxsize => 2})
       render.render('$a \ne b$')
     end
 
     assert_nothing_raised RangeError do
-      render = Mathematical::Render.new({:maxsize => 2147483647}) # signed long max
+      render = Mathematical.new({:maxsize => 2147483647}) # signed long max
       render.render('$a \ne b$')
     end
 
     assert_raise RangeError do
-      render = Mathematical::Render.new({:maxsize => 4294967295}) # unsigned long max
+      render = Mathematical.new({ :maxsize => 4_294_967_295 }) # unsigned long max
       render.render('$a \ne b$')
     end
   end
 
   def test_it_does_not_blow_up_on_bad_input
     assert_raise TypeError do
-      render = Mathematical::Render.new.render(23)
+      Mathematical.new.render(23)
     end
 
     assert_raise ArgumentError do
-      render = Mathematical::Render.new.render("No dollars")
+      Mathematical.new.render('No dollars')
+    end
+
+    assert_raise ArgumentError do
+      array = %w(foof poof)
+      Mathematical.new.render(array)
+    end
+
+    assert_raise ArgumentError do
+      array = ['$foof$', nil, '$poof$']
+      Mathematical.new.render(array)
     end
   end
 
   def test_it_returns_unmodified_string_for_max_parsing
-    render = Mathematical::Render.new
+    render = Mathematical.new
     output = nil
     # Much like above, this fails in mtx2MML, but should do nothing here
     text = '$\Huge \sqrt\sqrt\sqrt\sqrt\sqrt\sqrt\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{\sqrt{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}'
     assert_nothing_raised { output = render.render(text) }
     assert output == text
   end
+
+  def test_it_parses_all_possible_array_elements
+    render = Mathematical.new
+    array = ['$foof$', '$/this___istotallyfake$', '$poof$']
+    output = nil
+
+    _, err = capture_subprocess_io do
+      output = render.render(array)
+    end
+
+    assert_equal 3, output.length
+    assert_equal Hash, output.first.class
+    assert_equal Hash, output.last.class
+    assert_equal '$/this___istotallyfake$', output[1]
+    # array errors output to STDERR
+    assert_match /Failed to parse mtex: \$\/this___istotallyfake\$/, err
+  end
 end

data/test/mathematical/mathjax_test.rb

@@ -3,7 +3,7 @@ require 'nokogiri'
 
 class Mathematical::MathJaxTest < Test::Unit::TestCase
 
-  render_svg = Mathematical::Render.new
+  render_svg = Mathematical.new
 
   MATHJAX_TEST_TEST_DIR = File.join('ext', 'mathematical', 'mtex2MML', 'test', 'fixtures', 'MathJax')
   MATHJAX_TEST_TEX_DIR = File.join(MATHJAX_TEST_TEST_DIR, 'LaTeXToMathML-tex')
@@ -15,18 +15,10 @@ class Mathematical::MathJaxTest < Test::Unit::TestCase
       data = nil
       assert_nothing_raised { data = render_svg.render(tex_contents) }
 
-      render_mathml = Mathematical::Render.new({:format => "mathml"})
-      mathml = render_mathml.render(tex_contents)['mathml']
-
-      # TODO Lasem can't handle this node
-      if mathml =~ /menclose/
-        puts "\n\nSKIPPING #{tex}\n\n"
-      else
-        # assert the SVG actually rendered
-        doc = Nokogiri::HTML(data['svg'])
-        assert_empty doc.search(%(//svg[@width='0pt']))
-        assert_empty doc.search(%(//svg[@height='0pt']))
-      end
+      # assert the SVG actually rendered
+      doc = Nokogiri::HTML(data['svg'])
+      assert_empty doc.search(%(//svg[@width='0pt']))
+      assert_empty doc.search(%(//svg[@height='0pt']))
     end
   end
 end

data/test/mathematical/mathml_test.rb

@@ -13,9 +13,9 @@ class Mathematical::MathMLTest < Test::Unit::TestCase
      \end{pmatrix}
 $$
 '''
-    render = Mathematical::Render.new({:format => "mathml"})
-    mathml = render.render(string)["mathml"]
+    render = Mathematical.new({:format => :mathml})
+    mathml = render.render(string)['mathml']
 
-    assert_match /<math xmlns='http:\/\/www.w3.org\/1998\/Math\/MathML' display='block'><semantics><mrow><mrow><mo>\(/, mathml
+    assert_match %r{<math xmlns='http://www.w3.org/1998/Math/MathML' display='block'><semantics><mrow><mrow><mo>\(}, mathml
   end
 end

data/test/mathematical/multiples_test.rb

@@ -0,0 +1,68 @@
+require "test_helper"
+
+class Mathematical::MultiplesTest < Test::Unit::TestCase
+
+  def setup
+    @render = Mathematical.new(:base64 => true)
+  end
+
+  def test_it_works_for_a_single_numbered_equation
+    string = '''
+$$
+\begin{equation}
+ f(x)=(x+a)(x+b)
+\end{equation}
+$$
+'''
+
+    output = @render.render([string])
+    svg = output.first['svg']
+
+    assert_equal 1, svg.scan(/svg\+xml;/).size, 'should only contain one svg'
+    assert_match 'PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My', svg
+  end
+
+  def test_it_works_for_many_equations
+    inputs = []
+    (1..1000).each do |i|
+      string = """
+  $$
+  \\begin{equation}
+   f(#{i})=(x+a)(x+b)
+  \\end{equation}
+  $$
+  """
+      inputs << string
+    end
+
+    output = @render.render(inputs)
+    assert_equal 1000, output.length
+    output.each do |data|
+      assert_match 'PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My', data['svg']
+    end
+  end
+
+  def test_it_properly_accounts_for_equations
+    inputs = []
+    [1, 2].each do |i|
+      string = """
+  $$
+  \\begin{equation}
+   f(#{i})=(x+a)(x+b)
+  \\end{equation}
+  $$
+  """
+      inputs << string
+    end
+
+    inputs.insert(1, '$test$')
+    render = Mathematical.new({:format => :png})
+    output = render.render(inputs)
+    assert_equal 3, output.length
+    output.each_with_index do |data_hash, i|
+      header = data_hash['png'].unpack('H*').first.slice(0, 18)
+      File.open("#{fixtures_dir}/png/numeric_test_#{i + 1}.png", 'w') { |f| f.write(data_hash['png'])}
+      assert_equal header, '89504e470d0a1a0a00'
+    end
+  end
+end