macronconversions 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+*.swp
+.bundle
+pkg
+rdoc

data/Gemfile

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

data/LICENSE.textile

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) Steven G. Harms, http://stevengharms.com
+
+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.textile

@@ -0,0 +1,63 @@
+h1.   Macronconversions
+
+h2.  Who's This For?
+
+If you work with a language that makes use of vowels that have quantity...
+
+AND
+
+you need to generate those macron-bearing characters based on ASCII standards (because character panel lookup is not awesome)
+
+AND 
+
+you work with this language from the CLI
+
+THEN
+
+Wow, there's someone else besides me?
+
+*ahem*
+
+THEN Macronconversions may be the library for you!
+
+h2.  Macronconversions lets you convert easily between ASCII and funnt mulitbyte representations
+
+<pre>
+$ mconv -M  "laud\={a}re" 
+laudāre
+</pre>
+
+Coup-de-grâce
+
+<pre>
+$mdconv `mconv -M  "laud\={a}re" `
+laud\={a}re
+</pre>
+
+HTML codes instead
+
+<pre>
+$ mconv -H  "laud\={a}re" 
+laud&#x101;re
+</pre>
+
+h2.  Library
+
+Obviously the bin/ files are just thin wrappers around the core library.  Consult the RDoc for programmatic use.
+
+h2.  Install
+
+    gem install macronconversions
+
+h2. Current Status
+
+Stable
+
+h2.  Ridiculee-in-chief
+
+"Steven G. Harms":http://stevengharms.com
+
+h2.  Horrible Typos
+
+I'm currently relearning QWERTY from 10 years of Dvorak.  I should be getting better real soon now.
+

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+require "rake/rdoctask"
+
+# Add the bundler tasks, this comes because I used `bundle gem`.
+Bundler::GemHelper.install_tasks
+
+# `gem this` tasks
+# Generate documentation
+Rake::RDocTask.new do |rd| 
+ rd.rdoc_files.include("lib/**/*.rb")
+ rd.rdoc_dir = "rdoc"
+end
+
+#Added to get testing working
+require 'rake/testtask'
+Rake::TestTask.new(:test)

data/bin/mconv

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'macronconversions/macronconversions'
+
+require "getopt/std"
+opt = Getopt::Std.getopts("HMU")
+
+mode = if opt["H"]
+   :html
+elsif opt["M"]
+   :mc
+elsif opt["U"]
+   :utf8
+end
+
+puts Text::Latex::Util::Macronconversions.convert(ARGV.join(''), (mode.nil? ? :mc : mode) )

data/bin/mdconv

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'macronconversions/macronconversions'
+puts Text::Latex::Util::Macronconversions.deconvert(ARGV.join(''))

data/lib/macronconversions/conversion_structure.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+module Text
+  module Latex
+    module Util
+      module Macronconversions
+        # Chart used for ASCII LaTeX lookup against the formats
+        CONVERSION_TABLE = {
+          "\\={a}"   => 
+                        {
+                          :mc   => "ā",
+                          :utf8 => "\\xc4\\x81",
+                          :html => "ā"
+                        },
+          "\\={e}"   => 
+                        {
+                          :mc   => "ē",
+                          :utf8 => "\\xc4\\x93",
+                          :html => "ē"
+                        },
+          "\\={\\i}" => 
+                        {
+                          :mc   => "ī",
+                          :utf8 => "\\xc4\\xab",
+                          :html => "ī"
+                        },
+          "\\={o}"   => 
+                        {
+                          :mc   => "ō",
+                          :utf8 => "\\xc5\\x8d",
+                          :html => "ō"
+                        },
+          "\\={u}"   => 
+                        {
+                          :mc   => "ū",
+                          :utf8 => "\\xc5\\xab",
+                          :html => "ū"
+                        },
+          "\\={A}"   => 
+                        {
+                          :mc   => "Ā",
+                          :utf8 => "\\xc4\\x80",
+                          :html => "Ā"
+                        },
+          "\\={E}"   => 
+                        {
+                          :mc   => "Ē",
+                          :utf8 => "\\xc4\\x92",
+                          :html => "Ē"
+                        },
+          "\\={\\I}" => 
+                        {
+                          :mc   => "Ī",
+                          :utf8 => "\\xc4\\xaa",
+                          :html => "Ī"
+                        },
+          "\\={O}"   => 
+                        {
+                          :mc   => "Ō",
+                          :utf8 => "\\xc5\\x8c",
+                          :html => "Ō"
+                        },
+          "\\={U}"   => 
+                        {
+                          :mc   => "Ū",
+                          :utf8 => "\\xc5\\xaa",
+                          :html => "Ū"
+                        }
+        }                               
+      end
+    end
+  end
+end

data/lib/macronconversions/macronconversions.rb

@@ -0,0 +1,243 @@
+# coding: utf-8
+require 'macronconversions/conversion_structure'
+
+=begin rdoc
+== Synopsis
+
+Text::Latex::Util::MacronConversions:  module providing class methods to convert
+macron (dis-)enabled strings into the opposite.
+
+== Usage
+
+ require 'require macronconversions'
+
+== Description
+
+The class provides two class methods:  +convert+ and +deconvert+  In
+the event that you need to transform LaTeX-style markep into entities of
+some sort, use the former class.  In the event that you need to down-sample
+macron-characters into LaTeX-style, use the latter.
+
+== Example Code
+
+  # Basic conversion and advanced conversion
+  puts Text::Latex::Util::Macronconversions.convert("mon\\={e}re", 'mc') #=> monēre
+
+  # Complex de-conversion
+  puts MacronConversions::MacronDeConverter.new("laudāre") #=> "laud\={a}re"
+
+  # Coup de grace
+  puts MacronConversions::MacronDeConverter.new(
+    MacronConversions::MacronConverter.new('to bring up, educate: \={e}duc\={o}, \={e}duc\={a}re, \={e}duc\={a}v\={\i}, \={e}ducatus; education, educator, educable', 'mc').to_s)
+
+== Author     
+
+Steven G. Harms, http://www.stevengharms.com        
+
+=end
+# Module for manipulations on text documents
+module Text
+  # Module for working with LaTeX-formatted text
+  module Latex
+    # Utilities for generating LaTeX-formatted text
+    module Util
+      # == Synopsis
+      # 
+      # Text::Latex::Util::MacronConversions:  module providing class methods to convert
+      # macron (dis-)enabled strings into the opposite.
+      # 
+      # == Usage
+      # 
+      #  require 'require macronconversions'
+      # 
+      # == Description
+      # 
+      # The class provides two class methods:  +convert+ and +deconvert+  In
+      # the event that you need to transform LaTeX-style markep into entities of
+      # some sort, use the former class.  In the event that you need to down-sample
+      # macron-characters into LaTeX-style, use the latter.
+      # 
+      # == Example Code
+      # 
+      #   # Basic conversion and advanced conversion
+      #   puts Text::Latex::Util::Macronconversions.convert("mon\\={e}re", 'mc') #=> monēre
+      # 
+      #   # Complex de-conversion
+      #   puts MacronConversions::MacronDeConverter.new("laudāre") #=> "laud\={a}re"
+      # 
+      #   # Coup de grace
+      #   puts MacronConversions::MacronDeConverter.new(
+      #     MacronConversions::MacronConverter.new('to bring up, educate: \={e}duc\={o}, \={e}duc\={a}re, \={e}duc\={a}v\={\i}, \={e}ducatus; education, educator, educable', 'mc').to_s)
+      # 
+      # == Author     
+      # 
+      # Steven G. Harms, http://www.stevengharms.com        
+      module Macronconversions   
+                 
+      class << self
+          #  Deconverts a string that has macron-bearing vowels from the format to the ASCII representation used by LaTeX.
+          #  
+          #  The method is recursive and as such the 2 optional arguments are defined after the initial call.
+          #  Params:
+          #  +word+ :: (a string to convert
+          #  +from_format+ Never Directly Called:  Which format of macron should be expected?  See Macronconversions documentation
+          #  +conversion_chart+ Never Directly Called:  Which lookup table should the characters of word be tested against?
+          def deconvert(word, *arg)
+            return "" if word.empty?
+
+            # If the target has already been set, then we should respect that
+            # fact.  This makes recurses over longer strings faster
+            #
+            # If it has not already been set, we derive the type heuristically
+            mode =  ((! arg[0].nil?) or 
+                     (! arg[0]==:skip)) ?
+                  arg[0] 
+                :
+                  if word =~ /\&\#/
+                    :html
+                  elsif word =~ /[āēīōūĀĒĪŌŪ]/
+                    :mc 
+                  elsif word =~ /\\x/
+                    :utf8
+                  end
+            
+            # If the mode has not been set, we should have a plain old letter
+            # otherwise you want to die since we won't be able to build a
+            # chart for a non-existant format.
+            raise ArgumentError if (mode.nil? and word.slice(0) !~ /^[a-z]/)
+            
+            # Mutate the chart, but use the one given, if it was given (i.e.
+            # we are in a recursive call)
+            mutated_chart = {}
+            if arg[1].nil?
+              Text::Latex::Util::Macronconversions::CONVERSION_TABLE.each do |k,v|
+                mutated_chart[v[mode]]=k
+              end
+            else
+              mutated_chart = arg[1]
+            end
+            
+            # String to which the recurse's outputs will be appended
+            #
+            # All LaTeX Macron codes begin with an '=' token.  Scan for that
+            # using a RegEx.  The value is set to firstSlash.
+            # 
+            # This is just ugly, but is nothing to be afraid of.
+            #
+            # You look to see if the character is an ampersand.  That means
+            # you've got HTML entities.  Take the ending token of the entity
+            # and hold it, and then recursively send the tail to this method
+            # to be processed again.  A cheap serialization is established by
+            # sending the logic-requiring results on to recursive invocations
+            # 
+            # The same logic applies to the second if state, we're dealing
+            # with the representation of utf-8 characters
+            #
+            # The third case varies slightly, we have a multibyte *single*
+            # character.  This character can be slice!d off and the tail
+            # recursively sent onward.
+            #
+            # Lastly, if you have a plain character, follow the same model as
+            # the preceeding.
+
+            return_string = 
+              if word.slice(0) == "&"
+                word =~ /(&.*?;)(.*)/
+                _deconvert_char($1, mutated_chart) + 
+                      deconvert(word[($1.length)..-1], mode.to_sym, mutated_chart)                
+              elsif word.slice(0) == "\\"
+                word =~ /(^\\x..\\x..)(.*)/
+                _deconvert_char($1, mutated_chart) + 
+                      deconvert(word[($1.length)..-1], mode.to_sym, mutated_chart)
+              elsif word.slice(0) =~ /[āēīōūĀĒĪŌŪ]/
+                _deconvert_char(word.slice!(0),  mutated_chart) + 
+                      deconvert(word, mode.to_sym, mutated_chart)
+              else
+                # This is kinda ugly.  Particularly arg1.  
+                word.slice!(0) + deconvert(word, :skip, mutated_chart)
+              end
+
+            # Allow a block to be given to mutate the string after having been fabricated              
+            if block_given?
+              return_string = (yield return_string )
+            end
+
+            # debugger if word == "" 
+            return_string
+          end
+
+          # Macronconversions::convert is the routine that scans a token for LaTeX macron
+          # codes, recursively. Upon the indetification of a macron-ized character, it
+          # passes that character to the "private" method MacronConverter#_convert_char
+          # 
+          # Params:
+          # +word+ :: A string that uses the LaTeX standard for macron denotation
+          # +mode+ :: How the resultant string should be formatted (mc|utf8|html)
+          # 
+          # The resultant string may be operated upon by passing an optional block.
+          def convert(word, mode=:mc, &b)
+            # Ends the recurse
+            return "" if word.empty?
+            
+            # String to which the recurse's outputs will be appended
+            #
+            # All LaTeX Macron codes begin with an '\\={' token and end with
+            # '}' Scan for that using a RegEx thus creating a match and rest. 
+            # The match is passed to _convert_char and the rest is recursed to
+            # this method.
+            return_string = 
+              if word.slice(0) == "\\"
+                word =~ /(\\.*?})(.*)/
+                 _convert_char($1,mode.to_sym) + 
+                       convert(word[($1.length)..-1], mode.to_sym)
+              else
+                 word.slice(0) + convert(word[1..-1],mode)
+              end
+
+            # Allow a block to be given to mutate the string after having been fabricated              
+            if block_given?
+              return_string = (yield return_string )
+            end
+
+            return_string
+          end
+          
+          #####################################
+          # "Private" method
+          # (still available for unit testing, but you probably shouldn't mess with it)
+          # 
+          # Does the lookup to convert macron bearing character to LaTeX ASCII formatting 
+          #####################################
+          def _deconvert_char(c, chart)
+            begin
+              r = chart[c] 
+              raise if r.nil?
+            rescue
+              puts "_deconvert_char failed to find a match for [#{c}]"
+              pp chart
+              raise 
+            end
+            r
+          end
+
+          #####################################
+          # "Private" method
+          # (still available for unit testing, but you probably shouldn't mess with it)
+          # 
+          # Does the lookup to convert LaTeX ASCII to macron bearing character formatting
+          #####################################          
+          def _convert_char(c,mode)             
+            begin
+              r = Text::Latex::Util::Macronconversions::CONVERSION_TABLE[c][mode]
+              raise if r.nil?
+            rescue
+              puts "_convert_char failed to find a match for [#{c}]"
+              raise
+            end
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/macronconversions/version.rb

@@ -0,0 +1,10 @@
+module Text
+  module Latex
+    module Util
+      module Macronconversions
+        # Version "0.0.1"
+        VERSION = "0.0.1"
+      end
+    end
+  end
+end

data/lib/macronconversions.rb

@@ -0,0 +1,36 @@
+=begin rdoc
+== Synopsis
+
+Text::Latex::Util::MacronConversions:  module providing class methods to convert
+macron (dis-)enabled strings into the opposite.
+
+== Usage
+
+ require 'require macronconversions'
+
+== Description
+
+The class provides two class methods:  +convert+ and +deconvert+  In
+the event that you need to transform LaTeX-style markep into entities of
+some sort, use the former class.  In the event that you need to down-sample
+macron-characters into LaTeX-style, use the latter.
+
+== Example Code
+
+  # Basic conversion and advanced conversion
+  puts Text::Latex::Util::Macronconversions.convert("mon\\={e}re", 'mc') #=> monēre
+
+  # Complex de-conversion
+  puts MacronConversions::MacronDeConverter.new("laudāre") #=> "laud\={a}re"
+
+  # Coup de grace
+  puts MacronConversions::MacronDeConverter.new(
+    MacronConversions::MacronConverter.new('to bring up, educate: \={e}duc\={o}, \={e}duc\={a}re, \={e}duc\={a}v\={\i}, \={e}ducatus; education, educator, educable', 'mc').to_s)
+
+== Author     
+
+Steven G. Harms, http://www.stevengharms.com        
+
+=end
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'macronconversions/macronconversions'    

data/macronconversions.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "macronconversions/version"
+
+Gem::Specification.new do |s|
+  s.name        = "macronconversions"
+  s.version     = Text::Latex::Util::Macronconversions::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Steven G. Harms"]
+  s.email       = ["macron_conversions@sgharms.oib.com"]
+  s.homepage    = "http://rubygems.org/gems/macronconversions"
+  s.summary     = %q{Convert strings with Latex-style macron notation to
+  strings with embedded high-byte characters or UTF-8 escape codes.}
+  s.description = %q{Convert strings like 'laud\={a}re' to 'laudāre' using
+  ASCII-compatible escape codes.}
+
+  s.rubyforge_project = "macronconversions"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/testMacronConversion.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+require "test/unit"
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'macronconversions/macronconversions'
+
+class TestMacronConversion < Test::Unit::TestCase
+  def test_base_with_block
+    c=Text::Latex::Util::Macronconversions.convert("laud\\={a}re") do |s|
+      s.split(//).join('*')
+    end
+    assert_equal("l*a*u*d*ā*r*e", c)
+    c=Text::Latex::Util::Macronconversions.convert("laud\\={a}re") do |s|
+      s.split(//).length
+    end
+    assert_equal(7, c)
+    c=Text::Latex::Util::Macronconversions.convert("laud\\={a}re") do |s|
+      s.split(//)[4]
+    end
+    assert_equal("ā", c)
+  end
+  def test_conversions
+    # Base case
+    assert_equal "vanilla", Text::Latex::Util::Macronconversions.convert("vanilla")
+    assert_equal "laudāre", Text::Latex::Util::Macronconversions.convert("laud\\={a}re")
+    assert_equal "monēre", Text::Latex::Util::Macronconversions.convert("mon\\={e}re", 'mc')
+    assert_equal "to bring up, educate: ēducō, ēducāre, ēducāvī, ēducatus; education, educator, educable",  
+      Text::Latex::Util::Macronconversions.convert('to bring up, educate: \={e}duc\={o}, \={e}duc\={a}re, \={e}duc\={a}v\={\i}, \={e}ducatus; education, educator, educable', 'mc')
+    assert_equal "laud&#x101;re",    Text::Latex::Util::Macronconversions.convert("laud\\={a}re"  ,:html)
+    assert_equal "laud\\xc4\\x81re", Text::Latex::Util::Macronconversions.convert("laud\\={a}re"  ,:utf8)
+  end                
+  def test_character_conversion_mc
+    assert_equal "ā", Text::Latex::Util::Macronconversions._convert_char("\\={a}"  ,:mc)
+    assert_equal 'ē', Text::Latex::Util::Macronconversions._convert_char("\\={e}"  ,:mc)
+    assert_equal "ī", Text::Latex::Util::Macronconversions._convert_char("\\={\\i}",:mc)
+    assert_equal "ō", Text::Latex::Util::Macronconversions._convert_char("\\={o}"  ,:mc)
+    assert_equal "ū", Text::Latex::Util::Macronconversions._convert_char("\\={u}"  ,:mc)
+    assert_equal "Ā", Text::Latex::Util::Macronconversions._convert_char("\\={A}"  ,:mc)
+    assert_equal "Ē", Text::Latex::Util::Macronconversions._convert_char("\\={E}"  ,:mc)
+    assert_equal "Ī", Text::Latex::Util::Macronconversions._convert_char("\\={\\I}",:mc)
+    assert_equal "Ō", Text::Latex::Util::Macronconversions._convert_char("\\={O}"  ,:mc)
+    assert_equal "Ū", Text::Latex::Util::Macronconversions._convert_char("\\={U}"  ,:mc)    
+  end
+  def test_character_conversion_html
+    assert_equal "&#x101;", Text::Latex::Util::Macronconversions._convert_char("\\={a}"  ,:html)
+    assert_equal "&#x113;", Text::Latex::Util::Macronconversions._convert_char("\\={e}"  ,:html)
+    assert_equal "&#x12b;", Text::Latex::Util::Macronconversions._convert_char("\\={\\i}",:html)
+    assert_equal "&#x14d;", Text::Latex::Util::Macronconversions._convert_char("\\={o}"  ,:html)
+    assert_equal "&#x16b;", Text::Latex::Util::Macronconversions._convert_char("\\={u}"  ,:html)
+    assert_equal "&#x100;", Text::Latex::Util::Macronconversions._convert_char("\\={A}"  ,:html)
+    assert_equal "&#x112;", Text::Latex::Util::Macronconversions._convert_char("\\={E}"  ,:html)
+    assert_equal "&#x12a;", Text::Latex::Util::Macronconversions._convert_char("\\={\\I}",:html)
+    assert_equal "&#x14c;", Text::Latex::Util::Macronconversions._convert_char("\\={O}"  ,:html)
+    assert_equal "&#x16a;", Text::Latex::Util::Macronconversions._convert_char("\\={U}"  ,:html)  
+  end
+  def test_character_conversion_utf8
+    assert_equal "\\xc4\\x81", Text::Latex::Util::Macronconversions._convert_char("\\={a}"  ,:utf8)
+    assert_equal "\\xc4\\x93", Text::Latex::Util::Macronconversions._convert_char("\\={e}"  ,:utf8)
+    assert_equal "\\xc4\\xab", Text::Latex::Util::Macronconversions._convert_char("\\={\\i}",:utf8)
+    assert_equal "\\xc5\\x8d", Text::Latex::Util::Macronconversions._convert_char("\\={o}"  ,:utf8)
+    assert_equal "\\xc5\\xab", Text::Latex::Util::Macronconversions._convert_char("\\={u}"  ,:utf8)
+    assert_equal "\\xc4\\x80", Text::Latex::Util::Macronconversions._convert_char("\\={A}"  ,:utf8)
+    assert_equal "\\xc4\\x92", Text::Latex::Util::Macronconversions._convert_char("\\={E}"  ,:utf8)
+    assert_equal "\\xc4\\xaa", Text::Latex::Util::Macronconversions._convert_char("\\={\\I}",:utf8)
+    assert_equal "\\xc5\\x8c", Text::Latex::Util::Macronconversions._convert_char("\\={O}"  ,:utf8)
+    assert_equal "\\xc5\\xaa", Text::Latex::Util::Macronconversions._convert_char("\\={U}"  ,:utf8)        
+  end
+end

data/test/testMacronDeconversion.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+require "test/unit"
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'macronconversions/macronconversions'
+
+class TestMacronDeconversion < Test::Unit::TestCase
+  def test_basic_mc_deconversion
+    assert_equal "vanilla",      Text::Latex::Util::Macronconversions.deconvert("vanilla")
+    assert_equal "laud\\={a}re", Text::Latex::Util::Macronconversions.deconvert("laudāre") 
+    assert_equal "mon\\={e}re",  Text::Latex::Util::Macronconversions.deconvert("monēre")
+  end
+  def test_basic_utf8_deconversion
+    assert_equal "laud\\={a}re", Text::Latex::Util::Macronconversions.deconvert("laud\\xc4\\x81re")    
+  end
+  def test_basic_html_deconversion
+    assert_equal "laud\\={a}re", Text::Latex::Util::Macronconversions.deconvert("laud&#x101;re")
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: macronconversions
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Steven G. Harms
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-06 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: "Convert strings like 'laud\\={a}re' to 'laud\xC4\x81re' using\n  ASCII-compatible escape codes."
+email: 
+- macron_conversions@sgharms.oib.com
+executables: 
+- mconv
+- mdconv
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.textile
+- README.textile
+- Rakefile
+- bin/mconv
+- bin/mdconv
+- lib/macronconversions.rb
+- lib/macronconversions/conversion_structure.rb
+- lib/macronconversions/macronconversions.rb
+- lib/macronconversions/version.rb
+- macronconversions.gemspec
+- test/testMacronConversion.rb
+- test/testMacronDeconversion.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/macronconversions
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: macronconversions
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Convert strings with Latex-style macron notation to strings with embedded high-byte characters or UTF-8 escape codes.
+test_files: 
+- test/testMacronConversion.rb
+- test/testMacronDeconversion.rb