konjac 0.0.1 → 0.0.2

data/.autotest

@@ -0,0 +1,2 @@
+require "autotest/fsevent"
+require "autotest/growl"

data/.gitignore

@@ -1,4 +1,5 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
+*.gem
+.bundle
+.DS_Store
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/LICENSE

@@ -1,19 +1,19 @@
-Copyright (c) 2012 Bryan McKelvey
-
-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.
+Copyright (c) 2012 Bryan McKelvey
+
+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

@@ -1,36 +1,112 @@
-konjac
-======
-
-A Ruby command-line utility for translating files using a YAML wordlist
-
-Usage
------
-
-Create a file in `~/.konjac/` called `dict.yml`. The file should have the
-following format:
-
-    languages:
-      en:
-        - english
-        - eng
-      ja:
-        - japanese
-        - jpn
-
-    ...
-
-    terms:
-      -
-        en: japanese
-        ja: nihongo
-      -
-        en: book
-        ja: hon
-
-Name
-----
-
-*Hon'yaku* means "translation" in Japanese. This utility relies on a YAML
-wordlist. *Konnyaku* (Japanese for "konjac") rhymes with *hon'yaku* and is a
-type of yam. Also, Doraemon had something called a *hon'yaku konnyaku* that
-allowed one to listen to animals. But I digress.
+konjac
+======
+
+A Ruby command-line utility for translating files using a YAML wordlist
+
+Installation
+------------
+
+### Stable
+
+With [Ruby](http://www.ruby-lang.org/en/downloads/) installed, run the
+following in your terminal:
+
+    gem install konjac
+
+### Development
+
+With Ruby and [Git](http://help.github.com/set-up-git-redirect) installed,
+navigate in your command line to a directory of your choice, then run:
+
+    git clone git://github.com/brymck/konjac.git
+    cd konjac
+    rake install
+
+Usage
+-----
+
+Create a file in `~/.konjac/` called `dict.yml`. The file should have the
+following format:
+
+### Languages
+
+All languages for use within a particular dictionary file file must be described
+
+    languages:
+      en:
+        - english
+        - eng
+      ja:
+        - japanese
+        - jpn
+
+    ...
+
+    terms:
+      -
+        en: japanese
+        ja: nihongo
+      -
+        en: book
+        ja: hon
+
+You can then translate a file using the command line like so:
+
+    konjac translate *.txt from japanese to english
+
+
+Example
+-------
+
+~/.konjac/dict.yml:
+
+    -
+      en: I
+      ja: 僕
+    -
+      en: like
+      ja: 好き
+    -
+      en:
+        en: dog
+        ja: 犬
+      ja:
+        ja: 犬
+        en: dogs?
+    - # Periods
+      en:
+        en: ". "
+        ja: 。
+      ja:
+        ja: 。
+        en: !ruby/regexp '/\.\s?/'
+    - # Spaces between non-ASCII characters
+      en:
+        en: " "
+        ja: !ruby/regexp '/\s{2,}/'
+      ja:
+        ja: "\\1\\2"
+        en: !ruby/regexp '/([^a-z])\s([^a-z])/'
+
+~/.konjac/test_en.txt
+
+    I like dogs.
+
+Run
+
+    konjac translate ~/.konjac/test_en.txt into japanese
+
+~/.konjac/test_ja.txt (result):
+
+    僕好き犬。
+
+Now, obviously that does require some fiddling to make it more grammatical, but
+it's a start (=> `僕は犬が好きだ。`)
+
+Name
+----
+
+*Hon'yaku* means "translation" in Japanese. This utility relies on a YAML
+wordlist. *Konnyaku* (Japanese for "konjac") rhymes with *hon'yaku* and is a
+type of yam. Also, Doraemon had something called a *hon'yaku konnyaku* that
+allowed one to listen to animals. But I digress.

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require "bundler/gem_tasks"

data/bin/konjac

@@ -1,13 +1,13 @@
-#!/usr/bin/env ruby -Ku
-require "konjac"
-begin
-  Konjac::CLI.start
-rescue Interrupt => e
-  # Konjac.ui.error "\nQuitting..."
-  # Konjac.ui.debug e.backtrace.join("\n")
-  exit 1
-rescue SystemExit => e
-  exit e.status
-rescue Exception => e
-  raise e
-end
+#!/usr/bin/env ruby -Ku
+require "konjac"
+begin
+  Konjac::CLI.start
+rescue Interrupt => e
+  # Konjac.ui.error "\nQuitting..."
+  # Konjac.ui.debug e.backtrace.join("\n")
+  exit 1
+rescue SystemExit => e
+  exit e.status
+rescue Exception => e
+  raise e
+end

data/konjac.gemspec

@@ -1,24 +1,28 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "konjac/version"
-
-Gem::Specification.new do |s|
-  s.name        = "konjac"
-  s.version     = Konjac::VERSION
-  s.authors     = ["Bryan McKelvey"]
-  s.email       = ["bryan.mckelvey@gmail.com"]
-  s.homepage    = "http://brymck.herokuapp.com/"
-  s.summary     = %q{A Ruby command-line utility for translating files using a YAML wordlist}
-  s.description = %q{A Ruby command-line utility for translating files using a YAML wordlist}
-
-  s.rubyforge_project = "konjac"
-
-  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"]
-
-  # specify any dependencies here; for example:
-  s.add_development_dependency "rspec"
-  s.add_runtime_dependency "trollop"
-end
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "konjac/version"
+
+Gem::Specification.new do |s|
+  s.name        = "konjac"
+  s.version     = Konjac::VERSION
+  s.authors     = ["Bryan McKelvey"]
+  s.email       = ["bryan.mckelvey@gmail.com"]
+  s.homepage    = "http://brymck.herokuapp.com/"
+  s.summary     = %q{A Ruby command-line utility for translating files using a YAML wordlist}
+  s.description = %q{A Ruby command-line utility for translating files using a YAML wordlist}
+
+  s.rubyforge_project = "konjac"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sdoc"
+  s.add_development_dependency "autotest"
+  s.add_development_dependency "autotest-fsevent"
+  s.add_development_dependency "autotest-growl"
+end

data/lib/konjac/cli.rb

@@ -1,60 +1,66 @@
-module Konjac
-  module CLI
-    class << self
-      def start
-        show_help if ARGV.empty?
-
-        # Subcommand
-        case ARGV.shift
-        when "translate"
-          translate
-        when "add"
-        when "help"
-          show_help
-        else
-          raise ArgumentError.new("Valid commands are translate or add")
-        end
-      end
-
-      def show_help
-        puts "Help"
-        exit 0
-      end
-
-      private
-
-      def translate
-        from_index = ARGV.index("from")
-        to_index = ARGV.index("to")
-
-        # Get the to and from languages and delete them from ARGV
-        unless from_index.nil? || to_index.nil?
-          if from_index < to_index
-            ARGV.delete_at to_index
-            to_lang = ARGV.delete_at(to_index)
-            ARGV.delete_at from_index
-            from_lang = ARGV.delete_at(from_index)
-          else
-            ARGV.delete_at to_index
-            to_lang = ARGV.delete_at(to_index)
-            ARGV.delete_at from_index
-            from_lang = ARGV.delete_at(from_index)
-          end
-        else
-          puts "You must supply both a to and from language"
-          puts "Example: konjac translate foo.txt from english to japanese"
-          exit 1
-        end
-
-        # Get a list of files to translate
-        files = []
-        while !ARGV.empty?
-          files += Dir.glob(File.expand_path(ARGV.shift))
-        end
-        files.uniq!
-
-        Translator.translate files, from_lang, to_lang
-      end
-    end
-  end
-end
+module Konjac
+  module CLI
+    class << self
+      def start
+        show_help if ARGV.empty?
+
+        # Subcommand
+        case ARGV.shift
+        when "translate"
+          translate
+        when "add"
+        when "help"
+          show_help
+        else
+          raise ArgumentError.new("Valid commands are translate or add")
+        end
+      end
+
+      def show_help
+        puts "Help"
+        exit 0
+      end
+
+      private
+
+      def translate
+        # Get from language
+        from_index = ARGV.index("from")
+        unless from_index.nil?
+          ARGV.delete_at from_index
+          from_lang = ARGV.delete_at(from_index)
+        end
+        
+        # Get to language
+        to_index = ARGV.index("to") || ARGV.index("into")
+        if to_index.nil?
+          raise Exception::InvalidLanguageError.new("You must supply a to language")
+        else
+          ARGV.delete_at to_index
+          to_lang = ARGV.delete_at(to_index)
+        end
+
+        # Get a list of files to translate
+        files = []
+        while !ARGV.empty?
+          files += Dir.glob(File.expand_path(ARGV.shift))
+        end
+        raise Exception::FileNotFoundError.new("File not found") if files.empty?
+        files.uniq!
+
+        # Determine from language from first filename if not overridden
+        if from_lang.nil?
+          from_lang = Utils.extract_language_code_from_filename(files[0])
+          if from_lang.nil?
+            raise Exception::InvalidLanguageError.new("You must supply a to language")
+          end
+        end
+
+        from_lang = Language.find(from_lang).to_s
+        to_lang   = Language.find(to_lang).to_s
+
+        Translator.translate files, from_lang, to_lang
+      end
+    end
+  end
+end

data/lib/konjac/dictionary.rb

@@ -1,58 +1,118 @@
-require "yaml"
-
-module Konjac
-  module Dictionary
-    class << self
-      def load(from_lang, to_lang, opts = {})
-        opts = { :force => false }.merge(opts)
-        return @pairs if loaded? && !opts[:force]
-
-
-        dict_dir = File.expand_path("~/.konjac/")
-        dict_path = dict_dir + "/dict.yml"
-
-        unless File.file?(dict_path)
-          FileUtils.mkpath dict_dir
-          FileUtils.touch dict_path
-        end
-
-        @dictionary = ::YAML.load_file(dict_path)
-
-        # Parse languages
-        from_lang = parse_language(from_lang)
-        to_lang = parse_language(to_lang)
-
-        # Build a list of search and replace pairs
-        @pairs = []
-        @dictionary["terms"].each do |term|
-          if term.has_key?(from_lang) && term.has_key?(to_lang)
-            @pairs << [term[from_lang], term[to_lang]]
-          end
-        end
-
-        @loaded = true
-        @pairs
-      end
-
-      private
-
-      def loaded?
-        !!@loaded
-      end
-
-      def parse_language(lang)
-        if @dictionary["languages"].has_key?(lang)
-          return lang
-        else
-          @dictionary["languages"].each do |main, alternatives|
-            return main if alternatives.include?(lang)
-          end
-
-          # If no match is found, give an error message and exit
-          raise Exceptions::InvalidLanguageError.new("No match found for language \"#{lang}\"")
-          exit 1
-        end
-      end
-    end
-  end
-end
+require "yaml"
+
+module Konjac
+  module Dictionary
+    class << self
+      attr_accessor :from_lang, :to_lang, :path
+
+      def load(from_lang, to_lang, opts = {})
+        # Set defaults for optional arguments
+        opts = { :force => false, :name => "dict" }.merge(opts)
+        
+        # Allow both symbol and string arguments for languages
+        from_lang = from_lang.to_s
+        to_lang   = to_lang.to_s
+
+        # Build a regex template for the from language
+        from_template = build_regex_template(from_lang)
+
+        # Get full path from name
+        full_path = File.expand_path("~/.konjac/#{opts[:name]}.yml")
+        
+        return @pairs if loaded?(from_lang, to_lang, full_path) || opts[:force]
+
+        # Save variables to cache so we can avoid repetitive requests
+        cache_load from_lang, to_lang, opts
+        
+        # Make sure dictionary exists and load
+        verify_dictionary_exists full_path
+        @dictionary = ::YAML.load_file(full_path)
+
+        # Build a list of search and replace pairs
+        @pairs = []
+        @dictionary.each do |term|
+          if term.has_key?(to_lang)
+            # Build to term depending on whether it's a hash for complex
+            # matches or a simple string
+            if term[to_lang].is_a?(Hash)
+              to_term = term[to_lang][to_lang]
+
+              if term[to_lang].has_key?(from_lang)
+                from_term = term[to_lang][from_lang]
+              end
+            else
+              to_term = term[to_lang]
+            end
+
+            # Build from term if it doesn't already exist
+            if term.has_key?(from_lang) && from_term.nil?
+              from_term = term[from_lang]
+            end
+
+            unless from_term.nil?
+              # Build a regular expression if it isn't already one
+              # Note that this will apply word boundary rules, so to avoid them
+              # create a regular expression in the dictionary file
+              unless from_term.is_a?(Regexp)
+                from_term = Regexp.new(from_template % from_term)
+              end
+
+              @pairs << [ from_term, to_term ]
+            end
+          end
+        end
+
+        @pairs
+      end
+
+      # Verifies whether the dictionary exists on the specified path, creating
+      # a blank file if it doesn't
+      def verify_dictionary_exists(full_path)
+        unless File.file?(full_path)
+          FileUtils.mkpath File.dirname(full_path)
+          FileUtils.touch full_path
+        end
+      end
+
+      # Tests whether the same from language, to language and dictionary path
+      # have been loaded before
+      def loaded?(from_lang, to_lang, full_path)
+        (@from_lang == from_lang) &&
+        (@to_lang   == to_lang  ) &&
+        (@path      == full_path)
+      end
+
+      # Builds a regular expression template for the language depending on
+      # whether that language has word boundaries
+      def build_regex_template(lang)
+        if Language.has_spaces?(lang)
+          "\\b%s\\b"
+        else
+          "%s"
+        end
+      end
+
+      private
+
+      def parse_language(lang)
+        if @dictionary["languages"].has_key?(lang)
+          return lang
+        else
+          @dictionary["languages"].each do |main, alternatives|
+            return main if alternatives.include?(lang)
+          end
+
+          # If no match is found, give an error message and exit
+          raise Exceptions::InvalidLanguageError.new("No match found for language \"#{lang}\"")
+          exit 1
+        end
+      end
+
+      def cache_load(from_lang, to_lang, opts)
+        @from_lang = from_lang
+        @to_lang   = to_lang
+        @path      = path
+      end
+    end
+  end
+end

data/lib/konjac/{exceptions.rb → exception.rb}

@@ -1,5 +1,6 @@
-module Konjac
-  module Exceptions
-    class InvalidLanguageError < StandardError; end
-  end
-end
+module Konjac
+  module Exception
+    class FileNotFoundError < StandardError; end
+    class InvalidLanguageError < StandardError; end
+  end
+end

data/lib/konjac/language.rb

@@ -0,0 +1,256 @@
+module Konjac
+  module Language
+    class << self
+      LANGUAGES_WITHOUT_SPACES = [:ar, :he, :ja, :zh]
+      LIST = {
+        :ab => [:abkhazian,           :abk],
+        :aa => [:afar,                :aar],
+        :af => [:afrikaans,           :afr],
+        :ak => [:akan,                :aka],
+        :sq => [:albanian,            :alb, :sqi],
+        :am => [:amharic,             :amh],
+        :ar => [:arabic,              :ara],
+        :an => [:aragonese,           :arg],
+        :hy => [:armenian,            :arm, :hye],
+        :as => [:assamese,            :asm],
+        :av => [:avaric,              :ava],
+        :ae => [:avestan,             :ave],
+        :ay => [:aymara,              :aym],
+        :az => [:azerbaijani,         :aze],
+        :bm => [:bambara,             :bam],
+        :ba => [:bashkir,             :bak],
+        :eu => [:basque,              :baq, :eus],
+        :be => [:belarusian,          :bel],
+        :bn => [:bengali,             :ben],
+        :bh => [:bihari,              :bih],
+        :bi => [:bislama,             :bis],
+        :nb => [:bokmal,              :nob],
+        :bs => [:bosnian,             :bos],
+        :br => [:breton,              :bre],
+        :bg => [:bulgarian,           :bul],
+        :my => [:burmese,             :bur, :mya],
+        :es => [:castilian,           :spa],
+        :ca => [:catalan,             :cat],
+        :km => [:central_khmer,       :khm],
+        :ch => [:chamorro,            :cha],
+        :ce => [:chechen,             :che],
+        :ny => [:chewa,               :nya],
+        :ny => [:chichewa,            :nya],
+        :zh => [:chinese,             :chi, :zho],
+        :za => [:chuang,              :zha],
+        :cv => [:chuvash,             :chv],
+        :kw => [:cornish,             :cor],
+        :co => [:corsican,            :cos],
+        :cr => [:cree,                :cre],
+        :hr => [:croatian,            :hrv],
+        :cs => [:czech,               :cze, :ces],
+        :da => [:danish,              :dan],
+        :dv => [:dhivehi,             :div],
+        :dv => [:divehi,              :div],
+        :nl => [:dutch,               :dut, :nld],
+        :dz => [:dzongkha,            :dzo],
+        :en => [:english,             :eng],
+        :eo => [:esperanto,           :epo],
+        :et => [:estonian,            :est],
+        :ee => [:ewe,                 :ewe],
+        :fo => [:faroese,             :fao],
+        :fj => [:fijian,              :fij],
+        :fi => [:finnish,             :fin],
+        :nl => [:flemish,             :dut, :nld],
+        :fr => [:french,              :fre, :fra],
+        :ff => [:fulah,               :ful],
+        :gd => [:gaelic,              :gla],
+        :gl => [:galician,            :glg],
+        :lg => [:ganda,               :lug],
+        :ka => [:georgian,            :geo, :kat],
+        :de => [:german,              :ger, :deu],
+        :ki => [:gikuyu,              :kik],
+        :el => [:greek,               :gre, :ell],
+        :kl => [:greenlandic,         :kal],
+        :gn => [:guarani,             :grn],
+        :gu => [:gujarati,            :guj],
+        :ht => [:haitian,             :hat],
+        :ht => [:haitian_creole,      :hat],
+        :ha => [:hausa,               :hau],
+        :he => [:hebrew,              :heb],
+        :hz => [:herero,              :her],
+        :hi => [:hindi,               :hin],
+        :ho => [:hiri_motu,           :hmo],
+        :hu => [:hungarian,           :hun],
+        :is => [:icelandic,           :ice, :isl],
+        :io => [:ido,                 :ido],
+        :ig => [:igbo,                :ibo],
+        :id => [:indonesian,          :ind],
+        :ia => [:interlingua,         :ina],
+        :ie => [:interlingue,         :ile],
+        :iu => [:inuktitut,           :iku],
+        :ik => [:inupiaq,             :ipk],
+        :ga => [:irish,               :gle],
+        :it => [:italian,             :ita],
+        :ja => [:japanese,            :jpn],
+        :jv => [:javanese,            :jav],
+        :kl => [:kalaallisut,         :kal],
+        :kn => [:kannada,             :kan],
+        :kr => [:kanuri,              :kau],
+        :ks => [:kashmiri,            :kas],
+        :kk => [:kazakh,              :kaz],
+        :ki => [:kikuyu,              :kik],
+        :rw => [:kinyarwanda,         :kin],
+        :ky => [:kirghiz,             :kir],
+        :kv => [:komi,                :kom],
+        :kg => [:kongo,               :kon],
+        :ko => [:korean,              :kor],
+        :kj => [:kuanyama,            :kua],
+        :ku => [:kurdish,             :kur],
+        :kj => [:kwanyama,            :kua],
+        :ky => [:kyrgyz,              :kir],
+        :lo => [:lao,                 :lao],
+        :la => [:latin,               :lat],
+        :lv => [:latvian,             :lav],
+        :lb => [:letzeburgesch,       :ltz],
+        :li => [:limburgan,           :lim],
+        :li => [:limburger,           :lim],
+        :li => [:limburgish,          :lim],
+        :ln => [:lingala,             :lin],
+        :lt => [:lithuanian,          :lit],
+        :lu => [:luba_katanga,        :lub],
+        :lb => [:luxembourgish,       :ltz],
+        :mk => [:macedonian,          :mac, :mkd],
+        :mg => [:malagasy,            :mlg],
+        :ms => [:malay,               :may, :msa],
+        :ml => [:malayalam,           :mal],
+        :dv => [:maldivian,           :div],
+        :mt => [:maltese,             :mlt],
+        :gv => [:manx,                :glv],
+        :mi => [:maori,               :mao, :mri],
+        :mr => [:marathi,             :mar],
+        :mh => [:marshallese,         :mah],
+        :ro => [:moldavian,           :rum, :ron],
+        :ro => [:moldovan,            :rum, :ron],
+        :mn => [:mongolian,           :mon],
+        :na => [:nauru,               :nau],
+        :nv => [:navaho,              :nav],
+        :nv => [:navajo,              :nav],
+        :ng => [:ndonga,              :ndo],
+        :ne => [:nepali,              :nep],
+        :nd => [:north_ndebele,       :nde],
+        :se => [:northern_sami,       :sme],
+        :no => [:norwegian,           :nor],
+        :ii => [:nuosu,               :iii],
+        :ny => [:nyanja,              :nya],
+        :nn => [:nynorsk,             :nno],
+        :ie => [:occidental,          :ile],
+        :oc => [:occitan,             :oci],
+        :oj => [:ojibwa,              :oji],
+        :cu => [:old_church_slavonic, :chu],
+        :or => [:oriya,               :ori],
+        :om => [:oromo,               :orm],
+        :os => [:ossetian,            :oss],
+        :os => [:ossetic,             :oss],
+        :pi => [:pali,                :pli],
+        :pa => [:panjabi,             :pan],
+        :ps => [:pashto,              :pus],
+        :fa => [:persian,             :per, :fas],
+        :pl => [:polish,              :pol],
+        :pt => [:portuguese,          :por],
+        :pa => [:punjabi,             :pan],
+        :ps => [:pushto,              :pus],
+        :qu => [:quechua,             :que],
+        :ro => [:romanian,            :rum, :ron],
+        :rm => [:romansh,             :roh],
+        :rn => [:rundi,               :run],
+        :ru => [:russian,             :rus],
+        :sm => [:samoan,              :smo],
+        :sg => [:sango,               :sag],
+        :sa => [:sanskrit,            :san],
+        :sc => [:sardinian,           :srd],
+        :gd => [:scottish_gaelic,     :gla],
+        :sr => [:serbian,             :srp],
+        :sn => [:shona,               :sna],
+        :ii => [:sichuan_yi,          :iii],
+        :sd => [:sindhi,              :snd],
+        :si => [:sinhala,             :sin],
+        :si => [:sinhalese,           :sin],
+        :sk => [:slovak,              :slo, :slk],
+        :sl => [:slovenian,           :slv],
+        :so => [:somali,              :som],
+        :st => [:sotho,               :sot],
+        :nr => [:south_ndebele,       :nbl],
+        :es => [:spanish,             :spa],
+        :su => [:sundanese,           :sun],
+        :sw => [:swahili,             :swa],
+        :ss => [:swati,               :ssw],
+        :sv => [:swedish,             :swe],
+        :tl => [:tagalog,             :tgl],
+        :ty => [:tahitian,            :tah],
+        :tg => [:tajik,               :tgk],
+        :ta => [:tamil,               :tam],
+        :tt => [:tatar,               :tat],
+        :te => [:telugu,              :tel],
+        :th => [:thai,                :tha],
+        :bo => [:tibetan,             :tib, :bod],
+        :ti => [:tigrinya,            :tir],
+        :to => [:tonga,               :ton],
+        :ts => [:tsonga,              :tso],
+        :tn => [:tswana,              :tsn],
+        :tr => [:turkish,             :tur],
+        :tk => [:turkmen,             :tuk],
+        :tw => [:twi,                 :twi],
+        :ug => [:uighur,              :uig],
+        :uk => [:ukrainian,           :ukr],
+        :ur => [:urdu,                :urd],
+        :ug => [:uyghur,              :uig],
+        :uz => [:uzbek,               :uzb],
+        :ca => [:valencian,           :cat],
+        :ve => [:venda,               :ven],
+        :vi => [:vietnamese,          :vie],
+        :vo => [:volapuk,             :vol],
+        :wa => [:walloon,             :wln],
+        :cy => [:welsh,               :wel, :cym],
+        :fy => [:western_frisian,     :fry],
+        :wo => [:wolof,               :wol],
+        :xh => [:xhosa,               :xho],
+        :yi => [:yiddish,             :yid],
+        :yo => [:yoruba,              :yor],
+        :za => [:zhuang,              :zha],
+        :zu => [:zulu,                :zul]
+      }
+
+      # Finds the two-letter code for the specified language
+      def find(lang)
+        # Allow function to accept both symbol and string arguments
+        lang = lang.to_sym
+
+        if LIST.has_key?(lang)
+          # Shortcut for two-letter language codes
+          return lang
+        else
+          # Breaks away automatically if a match is found
+          LIST.each do |two_letter_code, alt_names|
+            return two_letter_code if alt_names.include?(lang)
+          end
+
+          # Return nil if nothing found
+          raise Exception::InvalidLanguageError.new("Language not found: #{lang}")
+        end
+      end
+
+      # Determine whether the specified language has spaces or not
+      def has_spaces?(two_letter_code)
+        !LANGUAGES_WITHOUT_SPACES.include?(two_letter_code)
+      end
+
+      private
+
+      # Convert to underscore case
+      def underscore(str)
+        str.to_s.                              # allow symbols and strings
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').  # underscore-delimit caps
+        gsub(/([a-z\d])\s?([A-Z])/,'\1_\2').   # underscore-delimit words
+        tr("-", "_").                          # dashes to underscores
+        downcase.                              # everything lowercase
+        to_sym                                 # convert to symbol
+      end
+    end
+  end
+end

data/lib/konjac/translator.rb

@@ -1,33 +1,24 @@
-module Konjac
-  module Translator
-    class << self
-      def translate(files, from_lang, to_lang)
-        pairs = Dictionary.load(from_lang, to_lang)
-
-        files.each do |source|
-          # Read in file and replace matches in content
-          content = File.read(source)
-          pairs.each do |pair|
-            content.gsub! pair[0], pair[1]
-          end
-
-          # Write changed content to file
-          File.open(build_converted_file_name(source), "w") do |file|
-            file.puts content
-          end
-        end
-      end
-
-      private
-
-      # Build converted file name by appending "_converted" to the file name
-      def build_converted_file_name(source)
-        dirname  = File.dirname(source)
-        basename = File.basename(source, ".*")
-        extname  = File.extname(source)
-        
-        "#{dirname}/#{basename}_converted#{extname}"
-      end
-    end
-  end
-end
+# coding: utf-8
+module Konjac
+  module Translator
+    class << self
+      def translate(files, from_lang, to_lang)
+        pairs = Dictionary.load(from_lang, to_lang)
+        
+        files.each do |source|
+          # Read in file and replace matches in content
+          content = File.read(source)
+          pairs.each do |pair|
+            search, replace = pair
+            content.gsub! search, replace
+          end
+
+          # Write changed content to file
+          File.open(Utils.build_converted_file_name(source, from_lang, to_lang), "w") do |file|
+            file.puts content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/konjac/utils.rb

@@ -0,0 +1,29 @@
+module Konjac
+  module Utils
+    class << self
+      # Extracts the two letter language code from a filename
+      def extract_language_code_from_filename(name)
+        match = File.basename(name, ".*").match(/_([a-z]{2})/i)
+
+        if match.nil?
+          nil
+        else
+          match[1]
+        end
+      end
+      
+      # Build converted file name by appending "_converted" to the file name
+      def build_converted_file_name(source, from_lang, to_lang)
+        # Get components of filename
+        dirname  = File.dirname(source)
+        basename = File.basename(source, ".*")
+        extname  = File.extname(source)
+
+        # Blank out the from language
+        basename.sub! Regexp.new("_#{from_lang}", "i"), ""
+        
+        "#{dirname}/#{basename}_#{to_lang}#{extname}"
+      end
+    end
+  end
+end

data/lib/konjac/version.rb

@@ -1,3 +1,3 @@
-module Konjac
-  VERSION = "0.0.1"
-end
+module Konjac
+  VERSION = "0.0.2"
+end

data/lib/konjac.rb

@@ -1,10 +1,12 @@
-require "konjac/version"
-autoload :FileUtils, "fileutils"
-
-module Konjac
-  autoload :CLI,        "konjac/cli"
-  autoload :Dictionary, "konjac/dictionary"
-  autoload :Exceptions, "konjac/exceptions"
-  autoload :Manager,    "konjac/manager"
-  autoload :Translator, "konjac/translator"
-end
+require "konjac/version"
+autoload :FileUtils, "fileutils"
+
+module Konjac
+  # Set up autoload for all modules
+  autoload :CLI,        "konjac/cli"
+  autoload :Dictionary, "konjac/dictionary"
+  autoload :Exception,  "konjac/exception"
+  autoload :Language,   "konjac/language"
+  autoload :Translator, "konjac/translator"
+  autoload :Utils,      "konjac/utils"
+end

data/spec/dictionary_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Dictionary do
+  before :each do
+
+  end
+
+  it "should correctly load YAML"
+end

data/spec/language_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Language do
+  it "should find English" do
+    Language.find(:english).should == :en
+    Language.find(:eng).should == :en
+  end
+
+  it "should find Japanese" do
+    Language.find(:japanese).should == :ja
+    Language.find(:jpn).should == :ja
+  end
+
+  it "should return equal results for both strings and symbols" do
+    Language.find(:english).should == Language.find("english")
+  end
+
+  it "should accurately underscore languages" do
+    # underscore is a private method
+    Language.__send__(:underscore, "English").should == :english
+    Language.__send__(:underscore, "Western Frisian").should == :western_frisian
+  end
+  
+  it "should know that English has spaces" do
+    Language.has_spaces?(:en).should == true
+  end
+
+  it "should know that Japanese does not have spaces" do
+    Language.has_spaces?(:ja).should == false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "konjac"
+include Konjac

data/spec/utils_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Utils do
+  it "should extract the correct language from a filename" do
+    Utils.extract_language_code_from_filename("test_en.txt").should == "en"
+  end
+
+  it "should correctly rename a file according to its target language" do
+    Utils.build_converted_file_name("./test_en.txt", "en", "ja").should == "./test_ja.txt"
+    Utils.build_converted_file_name("./test.txt", "en", "ja").should == "./test_ja.txt"
+    Utils.build_converted_file_name("./test_fr.txt", "en", "ja").should == "./test_fr_ja.txt"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konjac
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-10 00:00:00.000000000 Z
+date: 2012-01-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70101261736900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70101261736900
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &23263176 !ruby/object:Gem::Requirement
+  requirement: &70101261736280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,18 +32,51 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *23263176
+  version_requirements: *70101261736280
 - !ruby/object:Gem::Dependency
-  name: trollop
-  requirement: &23231568 !ruby/object:Gem::Requirement
+  name: sdoc
+  requirement: &70101261735680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: *70101261735680
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: &70101261734760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70101261734760
+- !ruby/object:Gem::Dependency
+  name: autotest-fsevent
+  requirement: &70101261733460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70101261733460
+- !ruby/object:Gem::Dependency
+  name: autotest-growl
+  requirement: &70101261732860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  version_requirements: *23231568
+  version_requirements: *70101261732860
 description: A Ruby command-line utility for translating files using a YAML wordlist
 email:
 - bryan.mckelvey@gmail.com
@@ -41,7 +85,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- .autotest
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE
 - README.md
@@ -51,10 +97,15 @@ files:
 - lib/konjac.rb
 - lib/konjac/cli.rb
 - lib/konjac/dictionary.rb
-- lib/konjac/exceptions.rb
-- lib/konjac/manager.rb
+- lib/konjac/exception.rb
+- lib/konjac/language.rb
 - lib/konjac/translator.rb
+- lib/konjac/utils.rb
 - lib/konjac/version.rb
+- spec/dictionary_spec.rb
+- spec/language_spec.rb
+- spec/spec_helper.rb
+- spec/utils_spec.rb
 homepage: http://brymck.herokuapp.com/
 licenses: []
 post_install_message: 
@@ -75,8 +126,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: konjac
-rubygems_version: 1.8.11
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A Ruby command-line utility for translating files using a YAML wordlist
-test_files: []
+test_files:
+- spec/dictionary_spec.rb
+- spec/language_spec.rb
+- spec/spec_helper.rb
+- spec/utils_spec.rb