ovec 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf233d8093609535f86f06d12e54d8d53ea44da0
+  data.tar.gz: 61af216b5f2b5bda2dafe0affd86d3991ac9b957
+SHA512:
+  metadata.gz: ae3384bf00f9d20dd2ab7cc398a70959a44454ed953c1f0ec9cbddb485fc06adeace43e1313baf8fdcea80f1bb7b45fa2459d7ec3437b65f7f981dc384858ddf
+  data.tar.gz: 11ffb6b266c098c33047a48962f461de4c602b77e5c9737739157f59816dc00632e12ac81b1a184016ea8b52876ce2e40893e8e809df9ac75455c51acab6643a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ovec.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Michal Pokorný
+
+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,33 @@
+# Ovec
+
+Ovec is a linter for Czech TeX documents inspired by the capabilities of Vlna by Petr Olšák (http://petr.olsak.net/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ovec'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ovec
+
+## Usage
+
+Use the installed binary `ovec` as a filter.
+Right now, it writes out some debug messages to stderr - this will be fixed in a later version.
+Usage example:
+
+    $ cat input.tex | ovec > output.tex
+
+## 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,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+ 
+Rake::TestTask.new do |t|
+  t.libs << 'lib/ovec'
+  t.test_files = FileList['test/lib/ovec/*.rb']
+  t.verbose = true
+end
+ 
+task :default => :test

data/TODO

@@ -0,0 +1,9 @@
+- vlnky kolem promennych: graf~$X$, promenna~$Y$, ...
+- \, v cislech misto mezery?
+- ,~... (respektive \dots; nechci za tim sezrat mezeru - ???)
+	- varovat na ...?
+- uvozovky (bacha na neparove). warn / correct?
+- vlnkovadlo dle Olsaka.
+- pozorovat ovlnkovany zdrojak.
+- nevlnkovat:
+	- obecne makra, ve kterych se nevlnkuje

data/bin/ovec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'ovec'
+
+content = ARGF.read
+
+parser = Ovec::Parser.new
+tree = parser.parse(content)
+
+tm = Ovec::TexManipulator.new
+tm.bind(tree)
+
+tier = Ovec::Tier.new
+
+tm.run_text_manipulator(tier)
+
+puts tree.to_tex

data/lib/ovec/nodes.rb

@@ -0,0 +1,127 @@
+module Ovec
+	class Node
+	end
+
+	class CommentNode < Node
+		def initialize(content)
+			@content = content
+		end
+
+		def to_tex
+			content
+		end
+
+		attr_reader :content
+	end
+
+	class TextCommandsNode < Node
+		# If verbatim, do not interpret content as actual text.
+		def initialize(command, content, text: true)
+			@command = command
+			@content = content
+			@text = text
+		end
+
+		def to_tex
+			"\\#@command{#{@content.to_tex}}"
+		end
+
+		def text?; @text; end
+
+		attr_reader :command
+		attr_reader :content
+	end
+
+	class VerbatimNode < Node
+		def initialize(command, delimiter, content)
+			@command = command
+			@delimiter = delimiter
+			@content = content
+		end
+
+		def left_delimiter
+			@delimiter
+		end
+
+		def right_delimiter
+			Parser.delimiter_right_side @delimiter
+		end
+
+		def to_tex
+			"\\#@command#{left_delimiter}#@content#{right_delimiter}"
+		end
+	end
+
+	class CommandsNode < Node
+		def initialize(content)
+			@content = content
+		end
+
+		def to_tex
+			"\\#{content}"
+		end
+
+		attr_reader :content
+	end
+
+	class MathNode < Node
+		INLINE = :inline
+		DISPLAY = :display
+
+		def initialize(type, content)
+			@type = type
+			@content = content
+		end
+
+		def to_tex
+			if type == INLINE
+				"$#{content}$"
+			else
+				"$$#{content}$$"
+			end
+		end
+
+		attr_reader :type
+		attr_reader :content
+	end
+
+	class TextNode < Node
+		def initialize(text)
+			@text = text
+		end
+
+		def length
+			text.length
+		end
+
+		def to_tex
+			text
+		end
+
+		attr_reader :text
+	end
+
+	class CombinedNode < Node
+		def initialize(content = [])
+			@content = content
+		end
+
+		def <<(thing)
+			@content << thing
+		end
+
+		def to_tex()
+			content.map(&:to_tex).join('')
+		end
+
+		def length
+			@content.length
+		end
+
+		def [](index)
+			@content[index]
+		end
+
+		attr_reader :content
+	end
+end

data/lib/ovec/parser.rb

@@ -0,0 +1,169 @@
+module Ovec
+	class ParseError < StandardError
+	end
+
+	# TODO: verbatimy; TeX prikazy obsahujici kusy k ovlnkovani
+
+	class Parser
+		NORMAL_REGEX = /\A([^\\$%])+/
+		# TODO: more escapes: there are probably 10x more...
+		COMMAND_REGEX = /\A\\([a-zA-Z0-9]+|[%:,\\])/
+		COMMENT_REGEX = /\A%.*$/
+
+		TEXT_COMMANDS = %w(textit textbf textsc title author)
+		# TODO: seznam prikazu, ve kterych se nevlnkuje
+	
+		NONTEXT_CONTENT_COMMANDS = %w() # TODO: treba \begin, \end, ...
+		
+		VERBATIM_COMMANDS = %w(verbatim verb)
+
+		private
+		def debug(*args)
+			$stderr.puts(*args)
+		end
+
+		def find_other_side(string, start, left = '{', right = '}')
+			level = 0
+			for i in start...string.length
+				if string[i] == left && (right != left || i == start)
+					level += 1 
+				elsif string[i] == right
+					level -= 1
+				end
+
+				return i if level == 0
+			end
+
+			raise ParseError, "No matching #{right} found for #{left} in #{string} from index #{start}."
+		end
+
+		public
+		def self.delimiter_right_side(left)
+			{
+				'{' => '}', '[' => ']', '(' => ')', '<' => '>'
+			}[left] || left
+		end
+
+		def eat_node(code, index)
+			to_eat = code[index...code.length]
+
+			if to_eat.empty?
+				raise ParseError, "Parsing an empty string"
+			end
+
+			# Cut off comments
+			match = COMMENT_REGEX.match(to_eat)
+			unless match.nil?
+				match = match[0]
+				node = CommentNode.new(match)
+
+				debug "Eaten #{match.length} chars of comments."
+				return node, match.length
+			end
+
+			# Cut off normal text
+			match = NORMAL_REGEX.match(to_eat)
+			unless match.nil?
+				match = match[0]
+				node = TextNode.new(match)
+
+				debug "Eaten #{match.length} chars of normal text."
+				return node, match.length
+			end
+
+			# Parse a command. If the command looks like a text-command, try to eat everything between { and }.
+			match = COMMAND_REGEX.match(to_eat)
+			unless match.nil?
+				command = match[1]
+				match_len = match[0].length
+				debug "Eating command #{command}."
+
+				if TEXT_COMMANDS.include?(command) || NONTEXT_CONTENT_COMMANDS.include?(command)
+					if to_eat.length > match_len && to_eat[match_len] == '{'
+						debug "Looks like a text command, trying to parse recursively."
+						begin
+							other_side = find_other_side(to_eat, match_len, '{', '}')
+
+							content = parse(code[index + match_len + 1...index + other_side])
+							# TODO: rename textcommands to something better: command with params?
+							node = TextCommandsNode.new(command, content, text: TEXT_COMMANDS.include?(command))
+
+							debug "Eaten #{other_side + 1} chars of text command."
+							return node, (other_side + 1)
+						rescue ParseError
+							debug "Parse error encountered. Giving up on this node."
+						end
+					end
+				end
+
+				if VERBATIM_COMMANDS.include?(command)
+					if to_eat.length <= match_len
+						raise ParseError, "Verbatim at EOF with no delimiter."
+					end
+
+					left_delimiter = to_eat[match_len]
+					right_delimiter = self.class.delimiter_right_side(left_delimiter)
+
+					# TODO: nesting in verbatims ???
+					other_side = find_other_side(to_eat, match_len, left_delimiter, right_delimiter)
+
+					content = to_eat[match_len + 1...other_side]
+
+					node = VerbatimNode.new(command, left_delimiter, content)
+
+					debug "Eaten #{other_side + 1} chars of verbatim."
+					return node, (other_side + 1)
+				end
+
+				node = CommandsNode.new(command)
+				
+				debug "Eaten #{match_len} chars of commands."
+				return node, match_len
+			end
+
+			if to_eat.length > 1 && to_eat[0..1] == "$$"
+				# Lookaround assertion to handle escaped dollars in math.
+				ending = to_eat[2...to_eat.length].index(/(?<!\\)\$\$/)
+				
+				if ending.nil?
+					raise ParseError, "Unterminated $$ starting at #{index}"
+				end
+
+				node = MathNode.new(MathNode::DISPLAY, to_eat[2...ending+2])
+				eaten = ending + 4
+				debug "Eaten #{eaten} chars of inline math."
+				return node, eaten
+			end
+
+			if to_eat[0] == '$'
+				# Lookaround assertion to handle escaped dollars in math.
+				ending = to_eat[1...to_eat.length].index(/(?<!\\)\$/)
+
+				if ending.nil?
+					raise ParseError, "Unterminated $ starting at #{index}"
+				end
+
+				node = MathNode.new(MathNode::INLINE, to_eat[1...ending+1])
+				eaten = ending + 2
+				debug "Eaten #{eaten} chars of inline math."
+				return node, eaten
+			end
+
+			raise ParseError, "Don't know how to parse '#{to_eat}'."
+		end
+
+		def parse(code)
+			result = CombinedNode.new
+
+			index = 0
+			while index < code.length
+				node, shift = eat_node(code, index)
+				index += shift
+
+				result << node
+			end
+
+			return result
+		end
+	end
+end

data/lib/ovec/tex_manipulator.rb

@@ -0,0 +1,29 @@
+module Ovec
+	class TexManipulator
+		def bind(root)
+			@root = root
+		end
+
+		private
+		def load_text_chunks_dfs(node)
+			case node
+			when Ovec::TextCommandsNode then
+				load_text_chunks_dfs(node.content) if node.text?
+			when Ovec::TextNode	then
+				@text_chunks << node.text
+			when Ovec::CombinedNode then
+				node.content.each { |subnode| 
+					load_text_chunks_dfs(subnode)
+				}
+			end
+		end
+
+		public
+		def run_text_manipulator(manipulator)
+			@text_chunks = []
+			load_text_chunks_dfs(@root)
+			manipulator.bind(@text_chunks)	
+			manipulator.run
+		end
+	end
+end

data/lib/ovec/text_manipulator.rb

@@ -0,0 +1,33 @@
+module Ovec
+	class TextManipulator
+		# Subclasses, note: once you change the length of a chunk, delimiters will no longer be correct.
+
+		def bind(chunks)
+			@chunks = chunks
+			@delimiters = [0]
+			chunks.each do |chunk|
+				@delimiters << @delimiters.last + chunk.length
+			end
+
+			_rejoin
+		end
+
+		protected
+
+		# Given an offset in the original string, returns the chunk and chunk offset
+		# that contains the refers to the same character.
+		def _find_chunk_and_offset(offset)
+			j = 0
+			while j < @delimiters.size - 1
+				break if @delimiters[j + 1] > offset
+				j += 1
+			end
+
+			return [ @chunks[j], offset - @delimiters[j] ]
+		end
+
+		def _rejoin
+			@joined = @chunks.join('')
+		end
+	end
+end

data/lib/ovec/tier.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby -w
+
+module Ovec
+	class Tier < TextManipulator
+		# The last character this regex matches is changed to a tilde.
+		REGEX = /(
+			((\p{Z}|\~|\n)[KkSsVvZzOoUu]\p{Z})|   # KSVZOU jako samostatne slovo
+			([\.\?\!](\p{Z}|\~)+[KSVZOUAI]\p{Z})| # KSVZOUAI na zacatku vety
+			(\A[KSVZOUAI]\p{Z})|                  # KSVZOUAI na zacatku textu
+			(\p{Z}(?=--(\p{Z}|\n)))|              # mezera, za kterou je pomlcka
+			(,(\p{Z}|\~|\n)+a\p{Z})               # ... modulo 10, a~timto prvkem ...; TODO: plati tohle i pro "i"?
+		)/x
+
+		# TODO: generally tie "5.~batalion", ...
+		# All changes within this regex are changed to a tilde.
+		DATE_REGEX = /(
+			(?<=\p{Z})\p{Nd}{1,2}\.\p{Z}
+			(\p{Nd}{1,2}\.|leden|únor|březen|duben|květen|červen|červenec|srpen|září|říjen|listopad|prosinec| # TODO: plne sklonovani? nebo nejaky wildcard?
+				ledna|února|března|dubna|května|června|července|srpna|září|října|listopadu|prosince)\p{Z}
+			\p{Nd}{4}(?=\p{Z}) # Datum jako "1. 5. 2013"
+		)/x
+
+		def run
+			# ~ neni mezi \p{Z}.
+			# TODO: moznosti na dvojpismenne predlozky
+			matches = @joined.to_enum(:scan, REGEX).map { Regexp.last_match }
+
+			# Matches may overlap, find all matches with more scans.
+			# TODO: optimize
+			until matches.empty?
+				for i in 0...matches.length
+					# TODO: check ze za tim neni tilda nikde (napr. na dalsim radku, par mezer pozdeji, ...)
+					match = matches[i]
+					change = match.end(0) - 1
+					chunk, offset = _find_chunk_and_offset(change)
+					chunk[offset] = '~'
+				end
+			
+				_rejoin
+				matches = @joined.to_enum(:scan, REGEX).map { Regexp.last_match }
+			end
+
+			# Dates can't overlap. 1 scan is enough.
+			matches = @joined.to_enum(:scan, DATE_REGEX).map { Regexp.last_match }
+			for i in 0...matches.length
+				match = matches[i]
+				for j in match.begin...match.end
+					if @joined[j] == ' '
+						chunk, offset = _find_chunk_and_offset(j)
+						chunk[offset] = '~'
+					end
+				end
+			end
+		end
+	end
+end

data/lib/ovec/version.rb

@@ -0,0 +1,3 @@
+module Ovec
+  VERSION = "0.0.2"
+end

data/lib/ovec.rb

@@ -0,0 +1,9 @@
+require "ovec/version"
+require "ovec/nodes"
+require "ovec/parser"
+require "ovec/tex_manipulator"
+require "ovec/text_manipulator"
+require "ovec/tier"
+
+module Ovec
+end

data/ovec.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ovec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ovec"
+  spec.version       = Ovec::VERSION
+  spec.authors       = ["Michal Pokorný"]
+  spec.email         = ["pok@rny.cz"]
+  spec.description   = %q{A TeX linter for the Czech language.}
+  spec.summary       = %q{Ovec inserts nonbreakable spaces into your Czech language TeX files.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+	spec.required_ruby_version = ">= 2"
+end

data/test/lib/ovec/parser.rb

@@ -0,0 +1,77 @@
+require_relative '../../test_helper'
+
+module Ovec
+	class ParserTest < Test::Unit::TestCase
+		def setup
+			@parser = Parser.new
+		end
+
+		def test_basic_text_parsing
+			text = "Hello world!"
+			node, eaten = @parser.eat_node(text, 0)
+			assert_equal text.length, eaten
+			assert node.is_a?(TextNode)
+			assert_equal text.length, node.length
+		end
+
+		def test_basic_math_parsing
+			text = "$10+5=7$"
+			node, eaten = @parser.eat_node(text, 0)
+			assert_equal text.length, eaten
+			assert node.is_a?(MathNode)
+			assert_equal node.type, MathNode::INLINE
+			assert_equal node.content, text[1...(text.length - 1)]
+		end
+
+		def test_basic_display_math_parsing
+			text = "$$10+5=7$$"
+			node, eaten = @parser.eat_node(text, 0)
+			assert_equal text.length, eaten
+			assert node.is_a?(MathNode)
+			assert_equal node.type, MathNode::DISPLAY
+			assert_equal node.content, text[2...(text.length - 2)]
+		end
+
+		def test_basic_composite_parsing
+			text = "Ahoj světe. $10 + 5 = 3$\n\n\tSbohem. $$X \geq 4$$"
+			result = @parser.parse(text)
+			assert result.is_a?(CombinedNode)
+			assert_equal text, result.to_tex
+		end
+
+		def test_escaped_dollar_math
+			input = "$$Ahoj\\$$Svete$$"
+			result = @parser.parse(input)
+			assert result.length == 1
+			assert result[0].is_a? MathNode
+			assert result[0].content == "Ahoj\\$$Svete"
+		end
+
+		def test_text_command_parsing
+			text = '\textbf{Ahoj. Tohle je \textit{text}, ktery se bude vlnkovat.}'
+			result = @parser.parse(text)
+			assert result.is_a?(CombinedNode)
+			assert result.length == 1	
+
+			node = result[0]
+			assert node.is_a?(TextCommandsNode)
+			assert node.command == "textbf"
+
+			node2 = node.content
+			assert node2.is_a?(CombinedNode)
+			assert node2.length == 3
+			assert node2[0].is_a?(TextNode)
+			assert node2[0].text == "Ahoj. Tohle je "
+			assert node2[1].is_a?(TextCommandsNode)
+			assert node2[1].command == "textit"
+			assert node2[1].content[0].text == "text"
+			assert node2[2].text == ", ktery se bude vlnkovat."
+		end
+
+		def test_command_parsed
+			text = '\blabla'
+			result = @parser.parse(text)
+			assert_equal text, result.to_tex
+		end
+	end
+end

data/test/lib/ovec/tex_manipulator.rb

@@ -0,0 +1,39 @@
+require_relative '../../test_helper'
+
+module Ovec
+	class TexManipulatorTest < Test::Unit::TestCase
+		def setup
+			@tm = TexManipulator.new
+			@tier = Tier.new
+			@parser = Parser.new
+		end
+
+		def test_commands_reversible
+			tex = '\heading{Ahoj}'
+			tree = @parser.parse(tex)
+			assert_equal tex, tree.to_tex
+		end
+
+		private
+		def assert_ties_to(input, output)
+			tree = @parser.parse(input)
+			assert tree.is_a?(CombinedNode)
+			@tm.bind(tree)
+			@tm.run_text_manipulator(@tier)
+			assert_equal output, tree.to_tex
+		end
+
+		public
+		def test_basic_tex
+			input = 'Ahoj svete. \\textbf{I v ceskych luzich dochazi k ubytku s\\textit{ prichodem} podzimu.}'
+			output = 'Ahoj svete. \\textbf{I~v~ceskych luzich dochazi k~ubytku s\\textit{~prichodem} podzimu.}'
+			assert_ties_to input, output
+		end
+
+		def test_with_verb
+			input = 'Ahoj. \verb|Tohle % je ve verbatimu, takze to neni komentar. V tomhle se nevlnkuje.| V tomhle kusu se uz zase vlnkuje.'
+			output = 'Ahoj. \verb|Tohle % je ve verbatimu, takze to neni komentar. V tomhle se nevlnkuje.| V~tomhle kusu se uz zase vlnkuje.'
+			assert_ties_to input, output
+		end
+	end
+end

data/test/lib/ovec/tier.rb

@@ -0,0 +1,65 @@
+require_relative '../../test_helper'
+
+module Ovec
+	class TierTest < Test::Unit::TestCase
+		def setup
+			@tier = Tier.new
+		end
+
+		def test_basic_without_ties
+			text = "Ahoj. Jak se máš?"
+			text_duplicate = text.dup
+			@tier.bind([text_duplicate])
+			@tier.run
+			assert_equal text, text_duplicate
+		end
+
+		private
+		def assert_ties_to(input, output)
+			input = [input] if input.is_a? String
+			output = [output] if output.is_a? String
+			text = input.dup
+			@tier.bind(test)
+			@tier.run
+			assert_equal text, outpu
+		end
+
+		def test_simple_tie
+			assert_ties_to "K blabla u blabla s blabla.", "K~blabla u~blabla s~blabla."
+		end
+
+		def test_array_tie
+			assert_ties_to [ "K blabla u", " blabla ", "s blabla.", " A blabla?" ], [ "K~blabla u", "~blabla ", "s~blabla.", " A~blabla?" ]
+		end
+
+		def test_regex_works
+			regex = Tier::REGEX
+			assert !("ahoj" =~ regex)
+			assert "~v " =~ regex
+			assert "Cau. A hrdy bud, zes vytrval." =~ regex
+		end
+
+		def test_hard_tie
+			assert_ties_to "I v ceskych luzich dochazi k ubytku s prichodem podzimu.",
+				             "I~v~ceskych luzich dochazi k~ubytku s~prichodem podzimu."
+		end
+
+		def test_tie_dash
+			assert_ties_to "Ach -- pomlcka!", "Ach~-- pomlcka!"
+			assert_ties_to "Ach --\npomlcka!", "Ach~--\npomlcka!"
+		end
+
+		def test_tie_across_newline
+			assert_ties_to "Pojednani pojednavajici\no pojednavani.", "Pojednavani pojednavajici\no~pojednavani."
+		end
+
+		def test_tie_a_after_pause
+			assert_ties_to "Kone se pasou, a ovce se pasou.", "Kone se pasou, a~ovce se pasou."
+		end
+
+		def test_tie_date
+			assert_ties_to "3. 4. 2012", "3.~4.~2012"
+			assert_ties_to "1. leden 1950", "1.~leden~1950"
+		end
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'ovec'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: ovec
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Michal Pokorný
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: A TeX linter for the Czech language.
+email:
+- pok@rny.cz
+executables:
+- ovec
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- bin/ovec
+- lib/ovec.rb
+- lib/ovec/nodes.rb
+- lib/ovec/parser.rb
+- lib/ovec/tex_manipulator.rb
+- lib/ovec/text_manipulator.rb
+- lib/ovec/tier.rb
+- lib/ovec/version.rb
+- ovec.gemspec
+- test/lib/ovec/parser.rb
+- test/lib/ovec/tex_manipulator.rb
+- test/lib/ovec/tier.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Ovec inserts nonbreakable spaces into your Czech language TeX files.
+test_files:
+- test/lib/ovec/parser.rb
+- test/lib/ovec/tex_manipulator.rb
+- test/lib/ovec/tier.rb
+- test/test_helper.rb