rbtex 0.1.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42bdca948bc59d0c62d2c239bbf8f9ff4ae9e7db
+  data.tar.gz: 9d8b08d16afaa14451f50f0fd876e07e770ffbe4
+SHA512:
+  metadata.gz: 76eaa5830d558bb87dcb27a76a39280cef27072ee54385b4bae48438d550e07924dbb9301de46db7d902aad06f0280115330497c277ef5a8bd17c39479366bf7
+  data.tar.gz: cd309360956ab1da0f41964bfddbd35a184ae189abfd1cffd287bd13569fff77763a13f1899000f384a2a79b0ff96f430d0b7ae8990c6d599a1324528889d3bc

data/bin/rblatex

@@ -0,0 +1,566 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'colorize'
+require 'table_flipper'
+
+################################################################################
+#
+# rblatex -- The RbTeX processor.
+#
+# @author  Steven Rosendahl
+# @version 0.1.6
+#
+# This is the processor for the RbTeX package. This processor does not handle
+# any of the TeX heavy lifting; rather, the processor only looks for certain
+# environments in a supplied TeX document. After several steps, control is
+# returned back over to TeX, where pdflatex is called on the generated .rtx
+# file. If no rbtex environments were found, then this program tells pdflatex
+# to compile the original document.
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 Steven Rosendahl
+# 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.
+################################################################################
+
+TEX_ENV_01_S = '\\begin{rbtex}'
+TEX_ENV_01_E = '\\end{rbtex}'
+
+VERSION='0.1.6'
+
+RB_REQUIRE = "require 'rbtex'"
+
+OUT_DELIM = "\u00b6".encode('utf-8')
+
+RB_METHOD_S = "def"
+RB_METHOD_E = "end"
+
+LOOP_START = "\#\#\#LOOP_START\#\#\#"
+LOOP_END = "\#\#\#LOOP_END\#\#\#"
+RBT_ENV_BEGIN = "\#\#\#RBT_ENV_BEGIN\#\#\#"
+RBT_ENV_END = "\#\#\#RBT_ENV_END\#\#\#"
+
+RB_CLASS_CREATE = "new"
+
+RB_KEYWORD_END = [
+    'begin',
+    'case',
+    'def',
+    'do',
+    'for',
+    'if',
+    'redo',
+    'rescue',
+    'unless',
+    'until',
+    'while'
+]
+
+RB_LOOP_SIGNIT = [
+    'while',
+    'for',
+    'until',
+    '.times',
+    '.upto',
+    '.each'
+]
+
+TEX_MOD = 'Tex.print'
+
+RBTEX_INSERT_LINE = "rbtexinsertedlinenumber"
+
+TEX_FILE = ARGV[0];                                         # The user supplied TeX document
+RB_FILE = "#{TEX_FILE}.rb"                                  # The generated Ruby File
+RBTEX_OUT = "#{TEX_FILE}.aux.rtx"                           # The generated output file
+RBTEX_FILE = "#{File.basename(TEX_FILE,".tex")}.rtx"        # The generated TeX File
+$rbenvs = 0;                                                # The number of rbtex environments found
+$defstack = []                                              # A mechanism for dertermining when fcns end
+$loopstack = []
+$customclasses = []
+$fcnref = {}
+$console = ""
+
+def main
+    if TEX_FILE
+        result = 0
+        puts "Welcome to rblatex v#{VERSION}!"
+        puts "Beginning to preprocess #{TEX_FILE}"
+        result = preprocess
+        if result == 0
+            if $rbenvs > 0
+                puts "#{$rbenvs} RbTeX envrioment(s) found"
+                puts 'Beginning interpretation of Ruby code!'
+                result = interp
+                if result == 0
+                    result = postprocess
+                else
+                    puts 'Failed to interpret.'
+                    puts 'Check stdio for the error.'
+                    return 2
+                end
+            else
+                puts 'No uses of RbTeX found'
+                puts 'Falling back to LaTeX with a --shell-escape'
+            end
+        else
+            puts 'Failed to preprocess for some reason.'
+            return 2
+        end
+        if result == 0
+            puts 'Giving control over to pdflatex.'
+            puts 'Thank you for choosing RbTeX!'
+            # Thread.new {
+            result = latexit
+            # }.join
+            if result == 0
+                puts 'done'
+                exit 0
+            else
+                puts "Oops, there was a LaTeX error".colorize(:red).on_black
+            end
+        else
+            puts 'Failed to postprocess.'
+            puts 'This is likely RbTeX\'s fault :('
+            return 2
+        end
+    else
+        puts 'No TeX file supplied. Try again with a valid TeX file!'
+    end
+end
+
+################################################################################
+# def preprocess
+#
+# Handles the inital ripping of code from the original TeX document supplied by
+# the user. Upon successful completion, the method will return 0.
+#
+################################################################################
+def preprocess
+    lineno = 0
+    shouldWrite = false
+    inFunction = false
+    inLoop = false
+    printer = File.open(RB_FILE,'w')
+    scanner = File.open(TEX_FILE,'r')
+    if printer && scanner
+        printer.puts RB_REQUIRE
+        scanner.each_line do |line|
+            lineno = lineno + 1
+            if (line.include? TEX_ENV_01_E) && !determineTexCommented(line, TEX_ENV_01_E)
+                puts "Encountered #{TEX_ENV_01_E} on line #{lineno}"
+                printer.puts "Tex.print('', 8888, ['nrbtev'])"
+                shouldWrite = false
+            end
+            if shouldWrite
+                stripped = line.strip
+                #parse custom class names
+                if stripped.include? 'class'
+                    $customclasses.push stripped[stripped.index(' ')..stripped.length].strip
+                end
+                # parse lines containing the Tex.print method
+                if (stripped.include? TEX_MOD) && !determineRubyCommented(stripped, TEX_MOD) && !inFunction
+                    printer.print appendLineNumberToTexPrintCall(stripped, lineno)
+                # parse situations containing classes
+                elsif (stripped.include? RB_CLASS_CREATE) && !determineRubyCommented(stripped, RB_CLASS_CREATE) && !inFunction
+                    shoudlDoPrintThing = false
+                    $customclasses.each do |saved|
+                        if stripped.include? saved
+                            shoudlDoPrintThing = true
+                            break
+                        end
+                    end
+                    if shoudlDoPrintThing
+                        printer.print appendLineNumberToInitialization(stripped, lineno)
+                    else
+                        printer.print stripped
+                    end
+                # parse methods
+                elsif (stripped.include? RB_METHOD_S) && !determineRubyCommented(stripped, RB_METHOD_S) && !inFunction
+                    puts "Processing function definition: found line containing #{stripped}"
+                    inFunction = true
+                    extracted = extractFunctionMeta stripped
+                    $fcnref.store(extracted[0], extracted[1])
+                    $defstack.push 1
+                    if (stripped.include? '(') && (stripped.include? ')')
+                        puts "Injection into formatted def as \( \)! Boo!"
+                    else
+                        puts "Injection into formatted def as _,_! This is preferrable."
+                    end
+                    printer.print appendLineNumberArgToFunctionDefinition stripped
+                # if we are in a function, things work differently
+                elsif inFunction
+                    puts "Parsing #{stripped} inside function..."
+                    printer.print stripped
+                    if (line.include? TEX_MOD) && !determineRubyCommented(line, "Tex")
+                        printer.print inLoop ?
+                            ", (#{RBTEX_INSERT_LINE}=#{RBTEX_INSERT_LINE}+1)" :
+                            ", #{RBTEX_INSERT_LINE}"
+                    end
+                    #determine if the line contains a block keyword
+                    RB_KEYWORD_END.each do |kwd|
+                        if line.include? kwd
+                            puts "Encountered '#{kwd}'; pushing onto stack..."
+                            $defstack.push kwd
+                            break
+                        end
+                    end
+                    #determine if the line contains a looping keyword
+                    RB_LOOP_SIGNIT.each do |kwd|
+                        # if line.include? kwd
+                        if loopcheck(kwd,line)
+                            puts "Located a loop of the form '#{kwd}'; pushing onto stack..."
+                            $loopstack.push kwd
+                            inLoop = true
+                            printer.seek(-1 * (stripped.length), IO::SEEK_CUR)
+                            printer.print "\nTex.print('',#{RBTEX_INSERT_LINE},['loop'])"
+                            printer.print "\n#{stripped}"
+                            break
+                        end
+                    end
+                    if line.include? 'end'
+                        puts "Encountered 'end'; popping off of stack..."
+                        $defstack.pop
+                        # puts "LOOPSTACK SIZE: #{$loopstack.any?}"
+                        if inLoop
+                            $loopstack.pop
+                            inLoop = $loopstack.any?
+                            if !inLoop
+                                printer.puts "\nTex.print('',#{RBTEX_INSERT_LINE},['nloop'])"
+                            end
+                        end
+                    end
+                    inFunction = $defstack.any?
+                else
+                    print "STRIPPED: #{stripped}  "
+                    deffed = false
+                    #look for looping mechanisms first
+                    RB_LOOP_SIGNIT.each do |loopsig|
+                        # if stripped.include? loopsig
+                        if loopcheck(loopsig, stripped)
+                            $loopstack.push loopsig
+                            printer.puts "\nTex.print('',0,['loop'])"
+                        end
+                    end
+                    printer.print stripped
+                    $fcnref.each do |fcn, args|
+                        if stripped.include? fcn
+                            if (line.include? '(') && (line.include? ')')
+
+                            else
+                                printer.print (args != 0) ? (", #{lineno}") : (" #{lineno}")
+                                break
+                            end
+                        end
+                    end
+                end
+                printer.puts ""
+                printer.puts ""
+            end
+            if (line.include? TEX_ENV_01_S) && !determineTexCommented(line, TEX_ENV_01_S)
+                puts "Encountered #{TEX_ENV_01_S} on line #{lineno}"
+                $rbenvs = $rbenvs + 1
+                shouldWrite = true
+            end
+        end
+    end
+    printer.close
+    scanner.close
+    return 0
+end
+
+################################################################################
+# def interp
+#
+# Runs the generated ruby file. This function returns the result of the system's
+# ruby call.
+#
+################################################################################
+def interp
+    rboutput = `ruby #{RB_FILE} #{RBTEX_OUT}`
+    if rboutput == ''
+        puts 'Your ruby file had no puts statments'.green
+    end
+    return 0
+end
+
+################################################################################
+# def postprocess
+#
+# Generates a new LaTeX document for compilation via pdflatex. This function
+# will return 0 upon successful completion.
+#
+################################################################################
+def postprocess
+    scannerB = File.open(TEX_FILE,'r')
+    printer = File.open(RBTEX_FILE,'w')
+    scannerA = nil
+
+    lineno = 1
+    csvcount = 0
+    inRb = false
+    repline = ""
+    replineno = -1
+
+    empty = File.zero?(RBTEX_OUT)
+
+    if !empty
+        # process the out file and the original tex file
+        scannerA = File.open(RBTEX_OUT)
+        scannerB.each_line do |line|
+            if (line.include? TEX_ENV_01_S) && !determineTexCommented(line, TEX_ENV_01_S)
+                inRb = true
+            end
+            if !inRb
+                # if we aren't in an rbtex environment, just go ahead and print the line verbatim
+                if !(line.include? LOOP_START)
+                    printer.puts line
+                end
+            else
+                # grab a line from the scanner
+                outline = scannerA.gets
+                puts "OUTLINE: #{outline}"
+                if outline != nil
+                    if outline.include? LOOP_START
+                        # there was once a loop, so print out the stuff all at once
+                        while (outline = scannerA.gets)
+                            if outline.include? LOOP_END
+                                break
+                            end
+                            printer.puts (outline.split(OUT_DELIM)[0])
+                        end
+                    elsif outline.include? RBT_ENV_END
+                        nln = scannerB.gets
+                        while nln != nil
+                            if nln.include? TEX_ENV_01_E
+                                break
+                            end
+                            nln = scannerB.gets
+                        end
+                        inRb = false
+                    else
+                        # just go along as normal
+                        split = outline.split(OUT_DELIM)
+                        puts "SPLIT: #{split}"
+                        replineno = split[1]
+                        repline = split[0]
+                        puts "Injecting '#{repline}' into rtx file"
+                        printer.puts repline
+                    end
+                end
+            end
+            if (line.include? TEX_ENV_01_E) && !determineTexCommented(line, TEX_ENV_01_E)
+                inRb = false
+            end
+            lineno = lineno + 1
+        end
+    else
+        scannerB.each_line do |line|
+            if (line.include? TEX_ENV_01_S) && !determineTexCommented(line, TEX_ENV_01_S)
+                inRb = true
+            end
+            if !inRb
+                printer.puts line
+            end
+            if (line.include? TEX_ENV_01_E) && !determineTexCommented(line, TEX_ENV_01_E)
+                inRb = false
+            end
+        end
+    end
+
+    printer.close
+    scannerB.close
+    finalScan
+    puts 'Finishing postprocess'
+    return 0
+end
+
+def finalScan
+    f = File.open(RBTEX_FILE, 'r+')
+    f.each do |line|
+        if (line.include? LOOP_END) || (line.include? LOOP_START)
+            f.seek(-1 * line.length, IO::SEEK_CUR)
+            f.write(' ' * (line.length - 1))
+            f.puts("")
+        end
+        if line.include? RBT_ENV_END
+            f.seek(-1 * line.length, IO::SEEK_CUR)
+            f.write(' ' * (line.length - 1))
+            f.puts("")
+        end
+    end
+    f.close()
+end
+
+################################################################################
+# def latexit
+#
+# Runs pdflatex on the generated TeX file.
+################################################################################
+def latexit
+    ret = -1
+    if $rbenvs > 0
+        ret = system("pdflatex --shell-escape #{RBTEX_FILE}") ? 0 : -1
+    else
+        ret = system("pdflatex --shell-escape #{TEX_FILE}") ? 0 : -1
+    end
+    return ret
+end
+
+################################################################################
+# def getLineFromString(line)
+#
+# Returns the RbTeX stored line number on a line.
+################################################################################
+def getLineFromString(line)
+    return line.slice!(line.index("\#~~!!") + 6)
+end
+
+def determineTexCommented(line, haystack)
+    in1 = line.index("\%")
+    in2 = line.index(haystack)
+    if in1 && in2
+        return in1 < in2
+    end
+    return false
+end
+
+def determineRubyCommented(line, haystack)
+    in1 = line.index("\#")
+    in2 = line.index(haystack)
+    if in1 && in2
+        return in1 < in2
+    end
+    return false
+end
+
+################################################################################
+# def extractFunctionMeta(line)
+#
+# Pulls out the function name and the number of arguments, and returns both.
+#
+# Methods in ruby can be formatted in several ways, so this method needs to
+# be able to parse out any of the different variations
+################################################################################
+def extractFunctionMeta(line)
+    res = ""
+    numret = 0
+    if line.include? '('
+        mindex = line.index('(')
+        sindex = line.index(')')
+        res = line[3..(mindex - 1)]
+        numret = line[(mindex - 1)..(sindex - 1)].length
+    else
+        spindex = (line.strip[3..line.length]).strip.index(' ')
+        if spindex != nil
+            res = line[3..spindex]
+            numret = 2
+        else
+            res = line[3..line.length]
+            numret = 0
+        end
+    end
+    return res.strip, numret
+end
+
+def appendLineNumberToTexPrintCall(line, number)
+    # if line.include? TEX_MOD && !determineRubyCommented(line, 'Tex')
+        # Three possibilities:
+        # => Tex.print(thing)
+        # => Tex.print(otherMethodCall())
+        # => Tex.print thing
+        # Output: Tex.print((thing), lineno)
+        if !line.include?("\"")
+            mline = line.gsub(/\s+/, "")
+        else
+            mline = line
+        end
+        return "#{TEX_MOD}(#{mline[9..(mline.length-1)]},#{number})"
+    # end
+end
+
+def appendLineNumberArgToFunctionDefinition(line)
+    # Four possibilities:
+    # => def fcn args       => def fcn(args,macro)
+    # => def fcn(args)      => def fcn((args),macro)
+    # => def fcn            => def fcn(macro)
+    # => def fcn()          => def fcn((macro))
+    # puts "APPEND LINE #{line}"
+    defgone = line.strip[3..line.length]
+    defgone = defgone.strip
+    # puts "APPEND DEFGONE #{defgone}"
+    if defgone.include? '('
+        defgone = defgone.gsub(/\s+/, "")
+        midn1 = defgone.index('(')
+        midn2 = defgone.index(')')
+        if defgone[midn1..midn2] == "()"
+            #case 4
+            return "def #{defgone[0..(defgone.index('(') - 1)]} #{RBTEX_INSERT_LINE}=0"
+        else
+            #case 2
+            return "def #{defgone[0..(defgone.index('(') -                                      1)]}(#{defgone[defgone.index('(')..defgone.length]},#{RBTEX_INSERT_LINE}=0)"
+        end
+    else
+        #either have case 1 or 3
+        if defgone.index(" ") != nil
+            #case 3
+            return "def #{defgone}, #{RBTEX_INSERT_LINE}=0"
+        else
+            #case 1
+            return "def #{defgone} #{RBTEX_INSERT_LINE}=0"
+        end
+    end
+end
+
+def appendLineNumberToInitialization(line, number)
+    newSpot = line.index(RB_CLASS_CREATE)
+    args = line[(newSpot + 3)..line.length].strip
+    defin = line[0..(newSpot + 3)].strip
+    if args.length != 0
+        return "#{defin}(#{args},#{number})"
+    else
+        return "#{defin}(#{number})"
+    end
+end
+
+def loopcheck(word, line)
+    ret = line.include? word
+    index = 0
+    indexa = -1
+    indexb = -1
+    line.split("").each do |char|
+        if char == "\"" && indexa == -1
+            indexa = index
+        elsif char == "\"" && indexb == -1
+            indexb = index
+        end
+        if indexa != -1 && indexb != -1
+            substr = line[indexa..indexb]
+            indexa = -1
+            indexb = -1
+            if substr.include? word
+                return false
+            end
+        end
+        index = index + 1
+    end
+    return ret
+end
+
+main

data/lib/rbtex.rb

@@ -0,0 +1,117 @@
+$out_file = ARGV[0]
+
+OUT_DELIM = "\u00b6".encode('utf-8')
+
+LOOP_START = "\#\#\#LOOP_START\#\#\#"
+LOOP_END = "\#\#\#LOOP_END\#\#\#"
+
+RBT_ENV_BEGIN = "\#\#\#RBT_ENV_BEGIN\#\#\#"
+RBT_ENV_END = "\#\#\#RBT_ENV_END\#\#\#"
+
+$pLoop = false
+
+if $out_file
+    File.new($out_file,"w").close
+end
+
+module Tex
+
+    def Tex.print(latex, number, bundle=[])
+        printToOutFile(latex, number, bundle)
+    end
+
+    def Tex.imath(math)
+        return "$#{math}$"
+    end
+
+    def Tex.cmath(math)
+        return "\\[#{math}\\]"
+    end
+
+    def Tex.center(latex)
+        return "\\begin{center}#{latex}\\end{center}"
+    end
+
+    def Tex.n
+        return "\\\\"
+    end
+
+    def Tex.logo
+        return "$\\RbTeX$"
+    end
+
+    def Tex.printToOutFile(line, number, bundle)
+        file = File.open($out_file, 'a')
+        if bundle.length == 0
+            file.puts "#{line}#{OUT_DELIM}#{number}"
+        else
+            case bundle[0]
+            when "loop"
+                $pLoop = true
+                file.puts LOOP_START
+            when "nloop"
+                $pLoop = false
+                file.puts LOOP_END
+            when "rbtev"
+                file.puts RBT_ENV_BEGIN
+            when "nrbtev"
+                file.puts RBT_ENV_END
+            else
+                file.puts $pLoop ? "#{line}" : "#{line}#{OUT_DELIM}#{number}"
+            end
+        end
+        file.close
+    end
+
+    class Table
+
+        def initialize(twodee, tabx=false)
+            @array = twodee
+            # @rowlines = rowlines
+            @tabx = tabx
+        end
+
+        def create
+            pme = "\\begin{#{@tabx ? "tabularx" : "tabular"}}#{@tabx ? "{\\textwidth}" : ""}{|"
+            i = 0
+            while i < @array[0].length
+                pme << "#{@tabx ? "X|" : "c|"}"
+                i = i + 1
+            end
+            pme << "} "
+            @array.each do |row|
+                pme << "\\hline "
+                rc = 0
+                row.each do |elem|
+                    pme << " #{elem} "
+                    if rc < row.length - 1
+                        pme << "&"
+                    end
+                    rc = rc + 1
+                end
+                pme << "\\\\ "
+            end
+            pme << "\\hline \\end{#{@tabx ? "tabularx" : "tabular"}}"
+            return pme
+        end
+
+        def colSum col
+            total = 0
+            i = 0
+            while i < @array.length
+                total = total + @array[i][col]
+                i = i + 1
+            end
+            return total
+        end
+
+        def rowSum row
+            total = 0
+            @array[row].each do |elem|
+                total = total + elem
+            end
+        end
+
+    end
+
+end

data/rbtex.gemspec

@@ -0,0 +1,21 @@
+require 'find'
+
+LANG="en_US.UTF-8"
+LC_ALL="en_US.UTF-8"
+
+Gem::Specification.new do |s|
+    s.name = 'rbtex'
+    s.version = '0.1.8'
+    s.date = '2016-03-26'
+    s.description = 'The rubylatex gem'
+    s.summary = 'RbTeX'
+    s.authors = ['Steven Rosendahl']
+    s.email = 'fsnewline@gmail.com'
+    s.files = ['./lib/rbtex.rb', './rbtex.gemspec']
+    s.executables << 'rblatex'
+    s.homepage = 'https://github.com/RubyLatex/RbTeX'
+    s.license = 'MIT'
+
+    s.add_development_dependency 'colorize', ['>= 0']
+    s.add_development_dependency 'table_flipper', ['>= 0']
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: rbtex
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+platform: ruby
+authors:
+- Steven Rosendahl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: table_flipper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The rubylatex gem
+email: fsnewline@gmail.com
+executables:
+- rblatex
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/rbtex.rb"
+- "./rbtex.gemspec"
+- bin/rblatex
+homepage: https://github.com/RubyLatex/RbTeX
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: RbTeX
+test_files: []