polytexnic 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c16ad8d5728f4ac2d87b81744b76c4a854e26d88
+  data.tar.gz: 5859a31e6722957809d2fd080c5170a05be7b5e1
+SHA512:
+  metadata.gz: 12e8c475ee247533ce1dcf0b1db8ad7cf3806a2cf81cf5726b935fbc0d23ac60ccc1998e7e38c5a234911be9ff370abdac44f6782caf5b5f1f28a3608240f3b2
+  data.tar.gz: 54b074f7a0df5e183cf333a52ceb5d4fa1b7addc3085c5b082da3c15f693a7afe03fba5295a8b140b85d48dfece737a8e74d258a021420935d497301007e584c

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log
+.highlight_cache
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+
+.DS_Store
+.api_token
+.project_id

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+polytexnic

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'debugger2' unless RUBY_VERSION < "2.0"
+  gem 'coveralls', require: false
+  gem 'growl'
+end
+
+group :development do
+  gem 'rspec', '~> 2.13'
+  gem 'guard-rspec'
+  gem 'rake'
+end

data/Guardfile

@@ -0,0 +1,15 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  ## Uncomment & edit below (and comment out above) to watch particular specs.
+  # watch(%r{^lib/(.+)\.rb$}) do
+  #   [
+  #     "spec/to_html/asides_spec.rb",
+  #     "spec/to_html/codelistings_spec.rb"
+  #   ]
+  # end
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Michael Hartl and Nick Merwin
+
+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,21 @@
+# polytexnic
+
+This is the `polytexnic` gem, which converts input in Markdown or PolyTeX to HTML and LaTeX. It currently has no standalone applications, but rather exists to support the `polytexnic` gem.
+
+## Installation
+
+This gem is installed automatically as a dependency of the `polytexnic` gem:
+
+    $ gem install polytexnic
+
+## Usage
+
+See [*The PolyTeXnic Book*](http://polytexnic.org/book) for more information.
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+Dir["tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/polytexnic/literal.rb

@@ -0,0 +1,299 @@
+module Polytexnic
+  module Literal
+
+    # Matches the line for syntax highlighting.
+    # %= lang:<language>
+    LANG_REGEX = /^\s*%=\s+lang:\s*(\w+)/
+
+    # Matches the line for code inclusion.
+    # %= <</path/to/code.ext
+    CODE_INCLUSION_REGEX = /^\s*%=\s+<<\s*\(          # opening
+                             \s*([\w\/]+\.?(\w*))     # path
+                             (?:,\s*lang:\s*(\w+))?   # optional lang
+                             \s*\)                    # closing paren
+                             /x
+
+    # Makes the caches for literal environments.
+    def cache_literal(polytex, format = :html)
+      output = []
+      lines = polytex.split("\n")
+      cache_literal_environments(lines, output, format)
+      output.join("\n")
+    end
+
+    # Handles environments that should be passed through the pipeline intact.
+    # The includes verbatim environments ('verbatim', 'Verbatim') and all the
+    # equation environments handled by MathJax ('equation', 'align', etc.).
+    # We take care to keep count of the number of begins we see so that the
+    # code handles nested environments correctly. I.e.,
+    #   \begin{verbatim}
+    #     \begin{verbatim}
+    #     \emph{foo bar}
+    #     \end{verbatim}
+    #   \end{verbatim}
+    #   lorem ipsum
+    # includes the internal literal text without stopping after the first
+    # \end{verbatim}.
+    #
+    # The control flow here is really nasty, but attempts to refactor it
+    # into a multi-pass solution have only resulted in even more complexity,
+    # and even then I've failed to get it to work. Thus, it shall for now
+    # follow the "ball of mud" pattern. (The only saving grace is that it's
+    # very thoroughly tested.)
+    def cache_literal_environments(lines, output, format)
+      latex = (format == :latex)
+      language = nil
+      in_verbatim = false
+      in_codelisting = false
+      while (line = lines.shift)
+        if line =~ LANG_REGEX && !in_verbatim
+          language = $1
+        elsif line =~ /\s*\\begin\{codelisting\}/ && !in_verbatim
+          in_codelisting = true
+          output << line
+        elsif line =~ /\s*\\end\{codelisting\}/ && !in_verbatim
+          in_codelisting = false
+          output << line
+        elsif line =~ CODE_INCLUSION_REGEX && !in_verbatim
+          # Reduce to a previously solved problem.
+          # We transform
+          # %= <<(/path/to/file.rb)
+          # to
+          # %= lang:rb
+          # \begin{code}
+          # <content of file.rb>
+          # \end{code}
+          # and then prepend the code to the current `lines` array.
+          filename = $1
+          if File.exist?(filename)
+            language = $3 || $2 || 'text'
+            code = ["%= lang:#{language}"]
+            code << '\begin{code}'
+            code.concat(File.read($1).split("\n"))
+            code << '\end{code}'
+            lines.unshift(*code)
+          else
+            lines.unshift("\\verb+ERROR: File '#{filename}' does not exist+")
+          end
+        elsif line.begin_literal?
+          in_verbatim = true
+          literal_type = line.literal_type
+          skip = line.math_environment? || latex
+          if line.math_environment? && !latex
+            output << '\begin{xmlelement*}{equation}'
+            output << '\begin{equation}'
+          end
+          math = line.math_environment?
+          label = nil
+          output << xmlelement(element(literal_type), skip) do
+            count = 1
+            text = []
+            text << line if line.math_environment? || (latex && !language)
+            while (line = lines.shift)
+              if line.begin_literal?(literal_type)
+                count += 1
+              elsif line.end_literal?(literal_type)
+                count -= 1
+                if count.zero?
+                  in_verbatim = false
+                  text << line if line.math_environment? || (latex && !language)
+                  break
+                end
+              end
+              label = line if math && line =~ /^\s*\\label{.*?}\s*$/
+              text << line
+            end
+            raise "Missing \\end{#{line.literal_type}}" if count != 0
+            content = text.join("\n")
+            if math
+              key = digest(content)
+              literal_cache[key] = content
+            elsif language.nil?
+              key = digest(content)
+              literal_cache[key] = content
+              tag = 'literal'
+            else
+              format = latex ? 'latex' : 'html'
+              id = "#{content}--#{language}--#{format}--#{in_codelisting}"
+              key = digest(id, salt: code_salt)
+              code_cache[key] = [content, language, in_codelisting]
+              tag = 'code'
+            end
+            if latex || tag == 'code' || math
+              key
+            else
+              xmlelement(tag) { key }
+            end
+          end
+          if math && !latex
+            unless label.nil?
+              key = digest(label)
+              math_label_cache[key] = label
+              output << key
+            end
+            output << '\end{equation}'
+            unless label.nil?
+              string = label.scan(/\{(.*?)\}/).flatten.first
+              string = string.gsub(':', '-').gsub('_', underscore_digest)
+              output << "\\xbox{data-label}{#{string}}"
+            end
+            output << '\end{xmlelement*}'
+          end
+          language = nil
+          (output << '') unless latex # Force the next element to be a paragraph
+        else
+          output << line
+        end
+      end
+    end
+
+    # Returns a permanent salt syntax highlighting cache.
+    def code_salt
+      'fbbc13ed4a51e27608037365e1d27a5f992b6339'
+    end
+
+    # Caches both display and inline math.
+    def cache_display_inline_math(output)
+      output.tap do
+        cache_display_math(output)
+        cache_inline_math(output)
+      end
+    end
+
+    # Caches display math.
+    # We support both TeX-style $$...$$ and LaTeX-style \[ ... \].
+    def cache_display_math(output)
+      output.gsub!(/\\\[(.*?)\\\]|\$\$(.*?)\$\$/m) do
+        math = "\\[ #{$1 || $2} \\]"
+        equation_element(math)
+      end
+    end
+
+    # Returns an equation element while caching the given content.
+    # We use this only for unnumbered, display equations, which requires using
+    # the `equation*` environment in place of `equation`.
+    def equation_element(content)
+      key = digest(content)
+      literal_cache[key] = content
+      "\\begin{xmlelement*}{equation}
+        \\begin{equation*}
+        #{key}
+        \\end{equation*}
+        \\end{xmlelement*}"
+    end
+
+    # Caches inline math.
+    # We support both TeX-style $...$ and LaTeX-style \( ... \).
+    # There's an annoying edge case involving literal dollar signs, as in \$.
+    # Handling it significantly complicates the regex, and necessesitates
+    # introducing an additional group to catch the character before the math
+    # dollar sign in $2 and prepend it to the inline math element.
+    def cache_inline_math(output)
+      output.gsub!(/(?:\\\((.*?)\\\)|([^\\]|^)\$(.*?[^\\])\$)/m) do
+        math = "\\( #{$1 || $3} \\)"
+        key = digest(math)
+        literal_cache[key] = math
+        $2.to_s + xmlelement('inline') { key }
+      end
+    end
+
+    # Converts references to hyperrefs.
+    # We want to convert
+    #   Chapter~\ref{cha:foo}
+    # to
+    #   \hyperref[cha:foo]{Chapter~\ref{cha:foo}
+    # which is then handled by LaTeX's hyperref package
+    # or by Tralics (where it converted to a link
+    # by the postprocessor).
+    # For completeness, we handle the case where the author neglects to
+    # use the nonbreak space ~.
+    def hyperrefs(string)
+      linked_item = "(Chapter|Section|Table|Box|Figure|Fig\.|Listing" +
+                    "|Equation|Eq\.)"
+      ref = /(?:#{linked_item}(~| ))*(\\(?:eq)*ref){(.*?)}/i
+      string.gsub!(ref) do
+        "\\hyperref[#{$4}]{#{$1}#{$2}#{$3}{#{$4}}}"
+      end
+    end
+
+    # Handles non-ASCII Unicode characters.
+    # The Tralics part of the pipeline doesn't properly handle Unicode,
+    # which is odd since Tralics is a French project. Nevertheless,
+    # we can hack around the restriction by treating non-ASCII Unicode
+    # characters as literal elements and simply pass them through the
+    # pipeline intact.
+    def cache_unicode(string)
+      non_ascii_unicode = /([^\x00-\x7F]+)/
+      string.gsub(non_ascii_unicode) do
+        key = digest($1)
+        literal_cache[key] = $1
+        xmlelement('unicode') { key }
+      end
+    end
+
+    def element(literal_type)
+      if math_environments.include?(literal_type)
+        'equation'
+      else
+        literal_type
+      end
+    end
+  end
+end
+
+# Returns supported math environments.
+# Note that the custom AMS-TeX environments are supported
+# in addition to the LaTeX defaults.
+def math_environments
+  %w[align align*
+     eqnarray eqnarray* equation equation*
+     gather gather* gathered
+     multline multline*
+    ]
+end
+
+class String
+
+  # Returns true if self matches \begin{...} where ... is a literal environment.
+  # Note: Support for the 'metacode' environment exists solely to allow
+  # meta-discussion of the 'code' environment.
+  def begin_literal?(literal_type = nil)
+    return false unless include?('\begin')
+    literal_type ||= "(?:verbatim|Verbatim|code|metacode|" +
+                     "#{math_environment_regex})"
+    match(/^\s*\\begin{#{literal_type}}\s*$/)
+  end
+
+  # Returns true if self matches \end{...} where ... is a literal environment.
+  def end_literal?(literal_type)
+    return false unless include?('\end')
+    match(/^\s*\\end{#{Regexp.escape(literal_type)}}\s*$/)
+  end
+
+  # Returns the type of literal environment.
+  # '\begin{verbatim}' => 'verbatim'
+  # '\begin{equation}' => 'equation'
+  # '\[' => 'display'
+  def literal_type
+    scan(/\\begin{(.*?)}/).flatten.first || 'display'
+  end
+
+  # Returns true if self begins a math environment.
+  def begin_math?
+    return false unless include?('\begin')
+    literal_type = "(?:#{math_environment_regex})"
+    match(/^\s*\\begin{#{literal_type}}\s*$/)
+  end
+
+  # Returns true if self matches a valid math environment.
+  def math_environment?
+    match(/(?:#{math_environment_regex})/)
+  end
+
+  private
+
+    # Returns a regex matching valid math environments.
+    def math_environment_regex
+      math_environments.map { |s| Regexp.escape(s) }.join('|')
+    end
+end

data/lib/polytexnic/postprocessor.rb

@@ -0,0 +1,28 @@
+# encoding=utf-8
+require 'cgi'
+require 'polytexnic/postprocessors/html'
+require 'polytexnic/postprocessors/latex'
+require 'polytexnic/postprocessors/polytex'
+
+module Polytexnic
+  module Postprocessor
+    include Html
+    include Latex
+    include Polytex
+
+    def postprocess(format)
+      case format
+      when :html
+        @html = xml_to_html(@xml)
+      when :latex
+        hyperrefs(@polytex)
+        raw_source = replace_hashes(@polytex)
+        @latex = highlight_source_code(raw_source)
+      when :polytex
+        remove_hypertarget
+        fix_verbatim_bug
+        write_polytex_code
+      end
+    end
+  end
+end