mathematical 1.3.0 → 1.4.0

data/ext/mathematical/mtex2MML/tests/numbered_equations.c

@@ -5,7 +5,7 @@
 
 static char *fixture_tex;
 static char *fixture_mml;
-static const char *result;
+static char *result;
 
 void test_numbered_equations__initialize(void)
 {
@@ -31,7 +31,7 @@ void test_numbered_equations__single_equation(void)
 {
   fixture_tex = read_fixture_tex("numbered_equations/single_equation.txt");
   fixture_mml = read_fixture_mml("numbered_equations/single_equation.html");
-  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), 1);
+  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), MTEX2MML_DELIMITER_DEFAULT, 1);
 
   cl_assert_equal_s(fixture_mml, result);
 }
@@ -40,7 +40,7 @@ void test_numbered_equations__multiple_equations(void)
 {
   fixture_tex = read_fixture_tex("numbered_equations/multiple_equations.txt");
   fixture_mml = read_fixture_mml("numbered_equations/multiple_equations.html");
-  mtex2MML_filter(fixture_tex, strlen(fixture_tex));
+  mtex2MML_filter(fixture_tex, strlen(fixture_tex), MTEX2MML_DELIMITER_DEFAULT);
   result = mtex2MML_output();
 
   cl_assert_equal_s(fixture_mml, result);
@@ -50,7 +50,7 @@ void test_numbered_equations__single_notag(void)
 {
   fixture_tex = read_fixture_tex("numbered_equations/single_notag.txt");
   fixture_mml = read_fixture_mml("numbered_equations/single_notag.html");
-  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), 1);
+  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), MTEX2MML_DELIMITER_DEFAULT, 1);
 
   cl_assert_equal_s(fixture_mml, result);
 }
@@ -59,7 +59,7 @@ void test_numbered_equations__single_nonumber(void)
 {
   fixture_tex = read_fixture_tex("numbered_equations/single_nonumber.txt");
   fixture_mml = read_fixture_mml("numbered_equations/single_nonumber.html");
-  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), 1);
+  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), MTEX2MML_DELIMITER_DEFAULT, 1);
 
   cl_assert_equal_s(fixture_mml, result);
 }
@@ -68,7 +68,7 @@ void test_numbered_equations__multiple_notag_nonumber(void)
 {
   fixture_tex = read_fixture_tex("numbered_equations/multiple_notag_nonumber.txt");
   fixture_mml = read_fixture_mml("numbered_equations/multiple_notag_nonumber.html");
-  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), 1);
+  result = mtex2MML_global_parse(fixture_tex, strlen(fixture_tex), MTEX2MML_DELIMITER_DEFAULT, 1);
 
   cl_assert_equal_s(fixture_mml, result);
 }

data/ext/mathematical/mtex2MML/tests/performance.c

@@ -0,0 +1,39 @@
+#include "clar.h"
+#include "clar_test.h"
+#include "deps/trim/trim.h"
+#include <stdio.h>
+#include <string.h>
+
+static char *fixture_tex;
+static char *fixture_mml;
+static char *result;
+
+void test_performance__initialize(void)
+{
+  global_test_counter++;
+}
+
+void test_performance__cleanup(void)
+{
+  if (fixture_tex != NULL) {
+    free(fixture_tex);
+  }
+
+  if (fixture_mml != NULL) {
+    free(fixture_mml);
+  }
+
+  if (result != NULL) {
+    free(result);
+  }
+}
+
+void test_performance__big_file(void)
+{
+  fixture_tex = read_fixture_tex("performance/big_file.txt");
+  fixture_mml = read_fixture_mml("performance/big_file.html");
+  mtex2MML_filter(fixture_tex, strlen(fixture_tex), MTEX2MML_DELIMITER_DEFAULT);
+  result = mtex2MML_output();
+
+  cl_assert_equal_s(fixture_mml, result);
+}

data/lib/mathematical.rb

@@ -1,5 +1,6 @@
 require 'mathematical/mathematical'
 
+require 'mathematical/configuration'
 require 'mathematical/corrections'
 require 'mathematical/validator'
 require 'mathematical/version'
@@ -15,25 +16,57 @@ class Mathematical
     :zoom => 1.0,
     :base64 => false,
     :maxsize => 0,
-    :format => :svg
+    :format => :svg,
+    :delimiter => [:dollar, :double]
   }
 
   XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 
-  def initialize(opts = {})
-    @config = DEFAULT_OPTS.merge(opts)
+  def initialize(options = {})
+    @config = DEFAULT_OPTS.merge(options)
 
     validate_config(@config)
 
     @config[:formatInt] = FORMAT_TYPES.index(@config[:format])
 
+    if @config[:delimiter].is_a?(Symbol)
+      @config[:delimiter] = Configuration::Delimiters.to_h[@config[:delimiter]]
+    else
+      @config[:delimiter] = @config[:delimiter].map do |delim|
+        Configuration::Delimiters.to_h[delim]
+      end.inject(0, :|)
+    end
+
     @processer = Mathematical::Process.new(@config)
   end
 
-  def render(maths)
+  def parse(maths)
     maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:parse))
+    result(result_data)
+  end
+  # TODO: deprecate this?
+  alias_method :render, :parse
+
+  def filter(maths)
+    maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:filter))
+    result(result_data)
+  end
+
+  def text_filter(maths)
+    maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:text_filter))
+    result(result_data)
+  end
+
+  def strict_filter(maths)
+    maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:strict_filter))
+    result(result_data)
+  end
 
-    result_data = @processer.process(maths)
+  def result(result_data)
     fail RuntimeError if !result_data.is_a?(Hash) && !result_data.is_a?(Array)
 
     if result_data.is_a? Array

data/lib/mathematical/configuration.rb

@@ -0,0 +1,19 @@
+require 'ruby-enum'
+
+class Configuration
+  class Delimiters
+    include Ruby::Enum
+
+    define :default, 0
+    define :dollar, 1
+    define :double, 2
+    define :parens, 4
+    define :brackets, 8
+
+    def self.option_exists?(option)
+      unless Delimiters.keys.include?(option)
+        fail TypeError, "delimiter type does not exist: #{option}"
+      end
+    end
+  end
+end

data/lib/mathematical/validator.rb

@@ -1,52 +1,38 @@
 class Mathematical
   module Validator
-    # explanation can be found at http://git.io/vJRBj
-    DOLLAR_MATCHER = /\A(?<!\\)(?:((?<!\$)\${1,2}(?!\$))(.*?(\g<1>)?.*?)(?<!\\)(?(1)(?<!\$)\1(?!\$)))\z/xm
 
     FORMAT_TYPES = [:svg, :png, :mathml].freeze
+    RENDER_TYPES = [:parse, :filter, :text_filter, :strict_filter].freeze
 
     def validate_config(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
+      if config[:delimiter].is_a?(Symbol)
+        Configuration::Delimiters.option_exists?(config[:delimiter])
+      elsif config[:delimiter].is_a?(Array)
+        config[:delimiter] = [nil] if config[:delimiter].empty?
 
-    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)
+        config[:delimiter].each do |delim|
+          Configuration::Delimiters.option_exists?(delim)
+        end
       else
-        validate_array(maths)
-      end
-    end
-
-    def validate_string(maths)
-      maths = maths.strip
-      unless valid_math_string(maths)
-        fail(ArgumentError, 'input must be in tex format (`$...$` or `$$...$$`)!')
+        fail(TypeError, 'delimiter type must be a valid symbol or array of symbols')
       end
-
-      maths
     end
 
-    def validate_array(maths)
-      maths.map do |m|
-        unless m.is_a?(String)
-          fail(ArgumentError, 'every element in array must be a string in tex format (`$...$` or `$$...$$`)!')
-        end
-        validate_string(m)
+    def validate_content(maths)
+      if maths.is_a? Array
+        maths.map { |m| validate_string(m) }
+      else
+        validate_string(maths)
       end
-
-      maths
     end
 
-    def valid_math_string(maths)
-      maths =~ DOLLAR_MATCHER
+    def validate_string(maths)
+      fail(ArgumentError, 'input must be string!') unless maths.is_a?(String)
+      maths.strip
     end
-
   end
 end

data/lib/mathematical/version.rb

@@ -1,3 +1,3 @@
 class Mathematical
-  VERSION = '1.3.0'
+  VERSION = '1.4.0'
 end

data/mathematical.gemspec

@@ -22,9 +22,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = %w(lib ext)
   spec.extensions    = ['ext/mathematical/extconf.rb']
 
+  spec.add_dependency 'ruby-enum', '~> 0.4'
+
   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 'bundler', '~> 1.2'
   spec.add_development_dependency 'minitest', '~> 5.6'
   spec.add_development_dependency 'math-to-itex', '~> 0.3'
   spec.add_development_dependency 'nokogiri', '~> 1.6'

data/test/mathematical/basic_test.rb

@@ -1,7 +1,7 @@
-require "test_helper"
+require 'test_helper'
+require 'nokogiri'
 
 class Mathematical::BasicTest < MiniTest::Test
-
   def test_it_has_a_version
     assert Mathematical::VERSION
   end
@@ -11,13 +11,66 @@ class Mathematical::BasicTest < MiniTest::Test
     render.render('$\pi$')
     output = render.render('$\pi$')[:data]
     assert_equal 1, output.scan(/<svg/).size, 'should only contain one svg'
+
+    # assert the SVG actually rendered
+    doc = Nokogiri::HTML(output)
+    assert_empty doc.search(%(//svg[@width='0pt']))
+    assert_empty doc.search(%(//svg[@height='0pt']))
   end
 
-  def test_handles_line_breaks
-    s = "$$x\ny$$"
-    render = Mathematical.new
-    output = render.render(s)[:data]
-    assert_equal 1, output.scan(/<svg/).size, 'should only contain one svg'
+  def test_inline
+    render = Mathematical.new(:format => :mathml)
+
+    fixture_tex = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'inline.txt'))
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'inline.html')).strip
+    result = render.parse(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+  def test_block
+    render = Mathematical.new(:format => :mathml)
+
+    fixture_tex = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'block.txt'))
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'block.html')).strip
+    result = render.parse(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+
+  def test_filter
+    render = Mathematical.new(:format => :mathml)
+
+    fixture_tex = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'filter.txt'))
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'filter.html')).strip
+    result = render.filter(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
   end
 
+  def test_text_filter
+    render = Mathematical.new(:format => :mathml)
+
+    fixture_tex = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'text_filter.txt'))
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'text_filter.html')).strip
+    result = render.text_filter(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+  def test_strict_filter
+    render = Mathematical.new(:format => :mathml)
+
+    fixture_tex = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'strict_filter.txt'))
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'basic', 'strict_filter.html')).strip
+    result = render.strict_filter(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
 end

data/test/mathematical/corrections_test.rb

@@ -1,4 +1,4 @@
-require "test_helper"
+require 'test_helper'
 
 class Mathematical::CorrectionsTest < MiniTest::Test
 

data/test/mathematical/delimiters_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class Mathematical::BasicTest < MiniTest::Test
+  def test_single_dollar
+    render = Mathematical.new(:delimiter => :dollar, :format => :mathml)
+
+    fixture_tex = "$\\pi$"
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'delimiters', 'single_dollar.html')).strip
+    result = render.render(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+  def test_double_dollar
+    render = Mathematical.new(:delimiter => :double, :format => :mathml)
+
+    fixture_tex = "$$\\pi$$"
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'delimiters', 'double_dollar.html')).strip
+    result = render.render(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+  def test_parens
+    render = Mathematical.new(:delimiter => :parens, :format => :mathml)
+
+    fixture_tex = "\\(\\pi\\)"
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'delimiters', 'parens.html')).strip
+    result = render.render(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+  def test_brackets
+    render = Mathematical.new(:delimiter => :brackets, :format => :mathml)
+
+    fixture_tex = "\\[\\pi\\]"
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'delimiters', 'brackets.html')).strip
+    result = render.render(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml, output)
+  end
+
+  def test_mixed
+    render = Mathematical.new(:delimiter => [:brackets, :double], :format => :mathml)
+
+    fixture_tex = "\\[\\alpha\\] $$\\beta$$"
+    fixture_mml = File.read(File.join(MTEX2MML_FIXTURES_DIR, 'delimiters', 'mixed.html')).strip
+    result = render.filter(fixture_tex)
+    output = result[:data]
+
+    assert_equal(fixture_mml.strip, output)
+  end
+end

data/test/mathematical/fixtures_test.rb

@@ -1,4 +1,5 @@
-require "test_helper"
+require 'test_helper'
+require 'math-to-itex'
 
 class Mathematical::FixturesTest < MiniTest::Test
   # the same SVGs sometimes get random id values, throwing off the tests
@@ -13,7 +14,7 @@ class Mathematical::FixturesTest < MiniTest::Test
       source = File.read(before)
 
       if ENV['MATHEMATICAL_GENERATE_SAMPLE']
-        next unless name.match /compliance/
+        next unless name.match(/compliance/)
         write_sample(source)
       end
 

data/test/mathematical/maliciousness_test.rb

@@ -1,4 +1,4 @@
-require "test_helper"
+require 'test_helper'
 
 class Mathematical::MaliciousnessTest < MiniTest::Test
 
@@ -19,7 +19,7 @@ class Mathematical::MaliciousnessTest < MiniTest::Test
 
     # need to pass a string here
     render = Mathematical.new
-    assert_raises TypeError do
+    assert_raises ArgumentError do
       Mathematical.new.render(123)
     end
   end
@@ -65,47 +65,39 @@ class Mathematical::MaliciousnessTest < MiniTest::Test
   end
 
   def test_it_does_not_blow_up_on_bad_input
-    assert_raises TypeError do
-      Mathematical.new.render(23)
-    end
-
     assert_raises ArgumentError do
-      Mathematical.new.render('No dollars')
-    end
-
-    assert_raises ArgumentError do
-      Mathematical.new.render('$$x')
+      Mathematical.new.render(23)
     end
 
-    assert_raises ArgumentError do
-      Mathematical.new.render('x$$')
-    end
+    # no delimiters
+    assert_equal Mathematical.new.render('x$$')[:exception].class, Mathematical::ParseError
+    assert_equal Mathematical.new.filter('$$x')[:exception].class, Mathematical::DocumentCreationError
+    assert_equal Mathematical.new.text_filter('No dollars')[:exception].class, Mathematical::DocumentCreationError
 
     assert_raises ArgumentError do
-      Mathematical.new.render('$$x$')
+      array = ['$foof$', nil, '$poof$']
+      Mathematical.new.render(array)
     end
 
     assert_raises ArgumentError do
-      Mathematical.new.render('$x$$')
+      array = ['$x$', 4]
+      Mathematical.new.render(array)
     end
 
-    assert_raises ArgumentError do
-      Mathematical.new.render('blah blah $x$ blah')
+    assert_raises TypeError do
+      Mathematical.new({ :delimiter => 'nope' }).render('$P$')
     end
 
-    assert_raises ArgumentError do
-      array = %w(foof poof)
-      Mathematical.new.render(array)
+    assert_raises TypeError do
+      Mathematical.new({ :delimiter => :nope }).render('$P$',)
     end
 
-    assert_raises ArgumentError do
-      array = ['$foof$', nil, '$poof$']
-      Mathematical.new.render(array)
+    assert_raises TypeError do
+      Mathematical.new({ :delimiter => [:dollar, 23] }).render('$P$',)
     end
 
-    assert_raises ArgumentError do
-      array = ['$x$', 4]
-      Mathematical.new.render(array)
+    assert_raises TypeError do
+      Mathematical.new({ :delimiter => [] }).render('$P$',)
     end
   end