konjac 0.1.4 → 0.1.5

data/README.md

@@ -53,20 +53,20 @@ Usage
 
 Translate all text files in the current directory from Japanese into English:
 
-    konjac translate *.txt from japanese to english
+    konjac translate *.txt --from japanese --to english
 
 Utilize a document's implied language (English) and translate into Japanese:
 
-    konjac translate test_en.txt into japanese
+    konjac translate test_en.txt --to japanese
 
 Use multiple dictionaries:
 
-    konjac translate financial_report_en.txt into japanese using finance
+    konjac translate financial_report_en.txt --to japanese --using finance
 
 Extract text from a DOCX document (creates a plain-text `test.konjac` file from
 `test.docx`):
 
-    konjac extract test
+    konjac export test
 
 Import tags file back into DOCX document (file created is named
 `test_imported.docx`):

data/konjac.gemspec

@@ -19,10 +19,12 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_runtime_dependency "nokogiri"
-  s.add_development_dependency "bundler"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "sdoc"
+  s.add_runtime_dependency "term-ansicolor"
+  s.add_runtime_dependency "trollop"
   s.add_development_dependency "autotest"
   s.add_development_dependency "autotest-fsevent"
   s.add_development_dependency "autotest-growl"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sdoc"
 end

data/lib/konjac/cli.rb

@@ -1,94 +1,114 @@
+require "term/ansicolor"
+require "trollop"
+
 module Konjac
   module CLI
-    autoload :SubCommand,        "konjac/cli/sub_command"
-    autoload :SubCommandManager, "konjac/cli/sub_command_manager"
+    class Color
+      extend Term::ANSIColor
+    end
 
     class << self
-      def init_sub_commands
-        @valid_commands = SubCommandManager.new
-        @valid_commands.add :extract, [:export, :e, :x], "Extract text from a DOCX file" do
-          Word.extract_docx_tags(ARGV)
-        end
-        @valid_commands.add :help, [:h, :"-h", :"?"], "Show help" do
-          show_help
-        end
-        @valid_commands.add :import, [:i, :m], "Import text back into a DOCX file" do
-          Word.import_docx_tags(ARGV)
-        end
-        @valid_commands.add :translate, [:t], "Translate a file" do
-          translate
-        end
-      end
+      SUB_COMMANDS = {
+        "edit"      => "Edit the tags file for a .docx file",
+        "export"    => "Export text tags from a .docx file",
+        "import"    => "Import text tags into a .docx file",
+        "translate" => "Translate a file according to ~/.konjac/dict.yml"
+      }
+      BANNER = <<-eos
+#{Color.bold "%s"}
 
-      def start
-        init_sub_commands
-        show_help if ARGV.empty?
+#{Color.bold "Usage:"}
+       konjac %s [#{Color.underscore "options"}] <filenames>+%s
+where [#{Color.underscore "options"}] are:
+eos
 
-        # Subcommand
-        sub_command = ARGV.shift
-        result = @valid_commands.execute(sub_command)
-
-        if result.nil?
-          show_help
-          raise InvalidCommandError.new("Invalid subcommand: #{sub_command}")
+      def start
+        global_opts = Trollop::options do
+          version "konjac #{Konjac::VERSION} (c) 2012 Bryan McKelvey"
+          banner BANNER % [
+            "konjac is a Ruby command-line utility for translating files " +
+              "using a YAML wordlist",
+            "[#{Color.underscore "subcommand"}]",
+            "\n\nwhere [#{Color.underscore "subcommand"}] is any one of:\n%s\n" %
+              Konjac::CLI.describe_subcommands
+          ]
+          opt :dry_run, "Don't actually do anything", :short => "n"
+          opt :quiet, "Suppress error messages"
+          stop_on SUB_COMMANDS.keys
         end
 
-        result
+        # Get subcommand
+        cmd = ARGV.shift
+        sc_banner = BANNER % [SUB_COMMANDS[cmd], cmd, ""]
+        cmd_opts = case cmd
+          when "edit"
+            Trollop::options do
+              banner sc_banner
+              opt :editor, "A command indicating which editor to use (e.g. vi %s)"
+            end
+            Word.edit_docx_tags ARGV, opts
+          when "extract", "export"
+            Trollop::options do
+              banner sc_banner
+            end
+            Word.extract_docx_tags ARGV
+          when "import"
+            Trollop::options do
+              banner sc_banner
+            end
+            Word.import_docx_tags ARGV
+          when "translate"
+            opts = Trollop::options do
+              banner sc_banner
+              opt :from, "The language from which to translate", :type => :string
+              opt :to, "The language into which to translate", :type => :string
+              opt :using, "The names of dictionaries to use", :type => :string,
+                :default => "dict", :multi => true
+              opt :use_cache, "Use cached dictionary", :default => false
+              opt :word, "Translate a word or phrase", :default => false
+            end
+            result = translate(ARGV, opts)
+            puts result if opts[:word]
+          else
+            Trollop::die "unknown subcommand #{cmd.inspect}"
+        end
       end
 
-      def show_help
-        puts @valid_commands.to_s
+      # Describe the subcommands available to the command line interface
+      def describe_subcommands
+        text = []
+        leftcol_width = SUB_COMMANDS.keys.map(&:length).max
+        SUB_COMMANDS.each do |sc, desc|
+          text << "  %#{leftcol_width}s:   %s" % [sc, desc]
+        end
+        text.join "\n"
       end
 
       private
+      
+      def translate(files, opts = {})
+        to_lang = Language.find(opts[:to]).to_s
 
-      def translate
-        # Get dictionaries
-        using_index = ARGV.index("using")
-        unless using_index.nil?
-          ARGV.delete_at using_index
-          dictionaries = []
-          while ARGV.length > using_index && !["from", "to", "into"].include?(ARGV[using_index])
-            dictionaries << ARGV.delete_at(using_index)
-          end
-        end
-        
-        # 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 InvalidLanguageError.new("You must supply a to language")
+        if opts[:word]
+          from_lang = Language.find(opts[:from]).to_s
+          Translator.translate_word ARGV[0].dup, from_lang, to_lang, opts
         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 FileNotFoundError.new("File not found") if files.empty?
-        files.uniq!
+          # Get a list of files to translate
+          parsed_files = Utils.parse_files(files)
+          raise FileNotFoundError.new("File not found") if parsed_files.empty?
 
-        # 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 InvalidLanguageError.new("You must supply a to language")
+          # Determine from language from first filename if not supplied
+          if opts[:from].nil?
+            opts[:from] = Utils.extract_language_code_from_filename(parsed_files[0])
+            if opts[:from].nil?
+              raise InvalidLanguageError.new("You must supply a from language")
+            end
           end
-        end
 
-        from_lang = Language.find(from_lang).to_s
-        to_lang   = Language.find(to_lang).to_s
+          from_lang = Language.find(opts[:from]).to_s
 
-        Translator.translate files, from_lang, to_lang, dictionaries
+          Translator.translate_files parsed_files, from_lang, to_lang, opts
+        end
       end
     end
   end

data/lib/konjac/dictionary.rb

@@ -7,28 +7,29 @@ module Konjac
 
       BLANK = /^\s*$/
 
-      def load(from_lang, to_lang, dictionaries, opts = {})
-        # Set defaults for optional arguments
-        opts = { :force => false }.merge(opts)
-        dictionaries = ["dict"] if dictionaries.nil?
-        
+      def load(from_lang, to_lang, opts = {})
         # Allow both symbol and string arguments for languages
         from_lang = from_lang.to_s
         to_lang   = to_lang.to_s
 
         # Ignore everything if we've been here before
-        return @pairs if loaded?(from_lang, to_lang, dictionaries) || opts[:force]
+        return @pairs if loaded?(from_lang, to_lang, opts[:using])
+
+        if opts[:use_cache]
+          @pairs = load_serialized(from_lang, to_lang, opts[:using])
+          return @pairs unless @pairs.nil?
+        end
         
         # Build a regex template for the from language
         from_template = build_regex_template(from_lang)
         to_template   = build_replacement_template(from_lang, to_lang)
 
         # Save variables to cache so we can avoid repetitive requests
-        cache_load from_lang, to_lang, dictionaries
+        cache_load from_lang, to_lang, opts[:using]
         
         # Make sure dictionary exists and load
         @dictionary = []
-        dictionaries.each do |dict|
+        opts[:using].each do |dict|
           if dict =~ /[\/.]/
             sub_dictionaries = Dir.glob(File.expand_path(dict))
           else
@@ -49,6 +50,7 @@ module Konjac
           @pairs << pair unless pair.nil?
         end
 
+        save_serialized from_lang, to_lang, dictionaries, @pairs
         @pairs
       end
 
@@ -104,9 +106,10 @@ module Konjac
       # Tests whether the same from language, to language and dictionary path
       # have been loaded before
       def loaded?(from_lang, to_lang, dictionaries)
-        (@from_lang    == from_lang) &&
-        (@to_lang      == to_lang  ) &&
-        (@dictionaries == dictionaries)
+        (@from_lang    == from_lang   ) &&
+        (@to_lang      == to_lang     ) &&
+        (@dictionaries == dictionaries) &&
+        !@pairs.nil?
       end
 
       # Builds a regular expression template for the language depending on
@@ -152,6 +155,30 @@ module Konjac
         @to_lang      = to_lang
         @dictionaries = dictionaries
       end
+      
+      def load_serialized(from_lang, to_lang, dictionaries)
+        file_name = File.expand_path("~/.konjac/marshal/%s_%s_%s" %
+          [from_lang, to_lang, dictionaries.join("_")])
+        if File.exists?(file_name)
+          Marshal.load file_name
+        else
+          nil
+        end
+      end
+
+      def save_serialized(from_lang, to_lang, dictionaries, pairs)
+        file_name = File.expand_path("~/.konjac/marshal/%s_%s_%s" %
+          [from_lang, to_lang, dictionaries.join("_")])
+
+        # Create directory structure if necessary
+        unless File.exists?(file_name)
+          FileUtils.mkdir_p File.dirname(file_name)
+        end
+
+        File.open(file_name, "w") do |file|
+          Marshal.dump(pairs, file)
+        end
+      end
     end
   end
 end

data/lib/konjac/exception.rb

@@ -1,5 +1,4 @@
 module Konjac
   class FileNotFoundError < StandardError; end
-  class InvalidCommandError < StandardError; end
   class InvalidLanguageError < StandardError; end
 end

data/lib/konjac/translator.rb

@@ -2,16 +2,13 @@
 module Konjac
   module Translator
     class << self
-      def translate(files, from_lang, to_lang, dictionaries)
-        pairs = Dictionary.load(from_lang, to_lang, dictionaries)
+      def translate_files(files, from_lang, to_lang, opts = {})
+        load_dictionary from_lang, to_lang, opts
         
         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
+          content = translate_content(content)
 
           # Write changed content to file
           File.open(Utils.build_converted_file_name(source, from_lang, to_lang), "w") do |file|
@@ -19,6 +16,27 @@ module Konjac
           end
         end
       end
+
+      def translate_word(word, from_lang, to_lang, opts = {})
+        load_dictionary from_lang, to_lang, opts
+
+        translate_content word
+      end
+
+      def translate_content(content)
+        @pairs.each do |pair|
+          search, replace = pair
+          content.gsub! search, replace
+        end
+
+        content
+      end
+
+      private
+
+      def load_dictionary(from_lang, to_lang, opts)
+        @pairs = Dictionary.load(from_lang, to_lang, opts)
+      end
     end
   end
 end

data/lib/konjac/utils.rb

@@ -24,6 +24,18 @@ module Konjac
         
         "#{dirname}/#{basename}_#{to_lang}#{extname}"
       end
+      
+      # Parses a list of files
+      def parse_files(files, ext = nil)
+        files = [files] unless files.is_a?(Array)
+        parsed_files = []
+        while !files.empty?
+          file = files.shift
+          file = file.sub(/\.[^\\\/]*$/, "") + ext unless ext.nil?
+          parsed_files += Dir.glob(File.expand_path(file))
+        end
+        parsed_files.uniq
+      end
     end
   end
 end

data/lib/konjac/version.rb

@@ -1,3 +1,3 @@
 module Konjac
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/konjac/word.rb

@@ -5,103 +5,107 @@ module Konjac
     class << self
       # Extracts the text content from a Microsoft Word 2003+ Document
       def import_docx_tags(files)
-        files.each do |file|
-          sub_files = Dir.glob(File.expand_path(file))
-          sub_files.each do |sub_file|
-            # Build the list of paths we need to work with
-            dirname   = File.dirname(sub_file)
-            basename  = File.basename(sub_file, ".*")
-            orig_docx = "#{dirname}/#{basename}.docx"
-            new_path  = "#{dirname}/#{basename}_imported.docx"
-            xml_path  = "#{dirname}/#{basename}.xml"
-            tags_path = "#{dirname}/#{basename}.konjac"
-            out_path  = "#{dirname}/word/document.xml"
-
-            # Open the original XML file and the updated tags
-            writer = Nokogiri::XML(File.read(xml_path))
-            nodes  = writer.xpath("//w:t")
-            tags   = TagManager.new(tags_path)
-
-            # Overwrite each <w:t> tag's content with the new tag
-            tags.all.each do |tag|
-              if tag.translated?
-                nodes[tag.index].content = tag.translated
-              end
+        sub_files = Utils.force_extension(files, ".docx")
+        sub_files.each do |sub_file|
+          # Build the list of paths we need to work with
+          dirname   = File.dirname(sub_file)
+          basename  = File.basename(sub_file, ".*")
+          orig_docx = "#{dirname}/#{basename}.docx"
+          new_path  = "#{dirname}/#{basename}_imported.docx"
+          xml_path  = "#{dirname}/#{basename}.xml"
+          tags_path = "#{dirname}/#{basename}.konjac"
+          out_path  = "#{dirname}/word/document.xml"
+
+          # Open the original XML file and the updated tags
+          writer = Nokogiri::XML(File.read(xml_path))
+          nodes  = writer.xpath("//w:t")
+          tags   = TagManager.new(tags_path)
+
+          # Overwrite each <w:t> tag's content with the new tag
+          tags.all.each do |tag|
+            if tag.translated?
+              nodes[tag.index].content = tag.translated
             end
+          end
 
-            # Create a directory for word/document.xml if necessary
-            unless File.directory?("#{dirname}/word")
-              FileUtils.mkdir "#{dirname}/word"
-            end
+          # Create a directory for word/document.xml if necessary
+          unless File.directory?("#{dirname}/word")
+            FileUtils.mkdir "#{dirname}/word"
+          end
 
-            # Write the modified XML to a file
-            File.open(out_path, "w") do |file|
-              file.write writer.to_xml.gsub(/\n\s*/, "").sub(/\?></, "?>\n<")
-            end
+          # Write the modified XML to a file
+          File.open(out_path, "w") do |file|
+            file.write writer.to_xml.gsub(/\n\s*/, "").sub(/\?></, "?>\n<")
+          end
 
-            # Copy the original file
-            FileUtils.cp orig_docx, new_path
+          # Copy the original file
+          FileUtils.cp orig_docx, new_path
 
-            # Add the new document XML to the copied file
-            system "cd #{dirname} && zip -q #{new_path} word/document.xml"
-          end
+          # Add the new document XML to the copied file
+          system "cd #{dirname} && zip -q #{new_path} word/document.xml"
         end
       end
 
       # Extracts the text content from a Microsoft Word 2003+ Document
       def extract_docx_tags(files)
-        files.each do |file|
-          sub_files = Dir.glob(File.expand_path(file))
-          sub_files.each do |sub_file|
-            # Build a list of all the paths we're working with
-            dirname    = File.dirname(sub_file)
-            basename   = File.basename(sub_file, ".*")
-            orig_docx  = "#{dirname}/#{basename}.docx"
-            xml_path   = "#{dirname}/#{basename}_orig.xml"
-            clean_path = "#{dirname}/#{basename}.xml"
-            tags_path  = "#{dirname}/#{basename}.konjac"
-
-            # Unzip the DOCX's word/document.xml file and pipe the output into
-            # an XML with the same base name as the DOCX
-            system "unzip -p #{orig_docx} word/document.xml > #{xml_path}"
-
-            # Read in the XML file and extract the content from each <w:t> tag
-            cleaner = Nokogiri::XML(File.read(xml_path))
-            File.open(tags_path, "w") do |tags_file|
-              # Remove all grammar and spellcheck tags
-              cleaner.xpath("//w:proofErr").remove
-
-              nodes = cleaner.xpath("//w:r")
-              prev = nil
-              nodes.each do |node|
-                unless prev.nil?
-                  if (prev.next_sibling == node) && compare_nodes(prev, node)
-                    begin
-                      node.at_xpath("w:t").content = prev.at_xpath("w:t").content +
-                        node.at_xpath("w:t").content
-                      prev.remove
-                    rescue
-                    end
+        sub_files = Utils.force_extension(files, ".docx")
+        sub_files.each do |sub_file|
+          # Build a list of all the paths we're working with
+          dirname    = File.dirname(sub_file)
+          basename   = File.basename(sub_file, ".*")
+          orig_docx  = "#{dirname}/#{basename}.docx"
+          xml_path   = "#{dirname}/#{basename}_orig.xml"
+          clean_path = "#{dirname}/#{basename}.xml"
+          tags_path  = "#{dirname}/#{basename}.konjac"
+
+          # Unzip the DOCX's word/document.xml file and pipe the output into
+          # an XML with the same base name as the DOCX
+          system "unzip -p #{orig_docx} word/document.xml > #{xml_path}"
+
+          # Read in the XML file and extract the content from each <w:t> tag
+          cleaner = Nokogiri::XML(File.read(xml_path))
+          File.open(tags_path, "w") do |tags_file|
+            # Remove all grammar and spellcheck tags
+            cleaner.xpath("//w:proofErr").remove
+
+            nodes = cleaner.xpath("//w:r")
+            prev = nil
+            nodes.each do |node|
+              unless prev.nil?
+                if (prev.next_sibling == node) && compare_nodes(prev, node)
+                  begin
+                    node.at_xpath("w:t").content = prev.at_xpath("w:t").content +
+                      node.at_xpath("w:t").content
+                    prev.remove
+                  rescue
                   end
                 end
-                
-                prev = node
-              end
-
-              # Write the tags file
-              index = 0
-              cleaner.xpath("//w:t").each do |node|
-                tags_file.puts "[[KJ-%i]]%s" % [index, additional_info(node)]
-                tags_file.puts "> %s" % node.content
-                index += 1
               end
+              
+              prev = node
             end
 
-            # Write the cleaned-up XML to a file for inspection
-            File.open(clean_path, "w") do |xml|
-              xml.puts cleaner.to_xml
+            # Write the tags file
+            index = 0
+            cleaner.xpath("//w:t").each do |node|
+              tags_file.puts "[[KJ-%i]]%s" % [index, additional_info(node)]
+              tags_file.puts "> %s" % node.content
+              index += 1
             end
           end
+
+          # Write the cleaned-up XML to a file for inspection
+          File.open(clean_path, "w") do |xml|
+            xml.puts cleaner.to_xml
+          end
+        end
+      end
+
+      # Opens the .konjac tag files for the specified DOCX files
+      def edit_docx_tags(files)
+        sub_files = Utils.force_extension(files, ".konjac")
+        sub_files.each do |sub_file|
+          system "$EDITOR #{sub_file}"
         end
       end
 

data/spec/cli_spec.rb

@@ -12,7 +12,7 @@ describe CLI do
 
   it "should fail on an invalid subcommand" do
     set_argv "invalid"
-    lambda { CLI.start }.should raise_error InvalidCommandError
+    lambda { CLI.start }.should raise_error SystemExit
   end
 
   describe "temporary files" do
@@ -32,25 +32,15 @@ describe CLI do
       @english.rewind
 
       # Set ARGV
-      set_argv "translate", @english.path, "into", "japanese", "using",
-        @dictionary.path
+      set_argv "translate", "-t", "japanese", "-u", @dictionary.path,
+        @english.path
     end
 
     it "should correctly translate English text" do
-      begin
-        CLI.start
-        converted_path = Utils.build_converted_file_name(@english.path, "en", "ja")
-        File.read(@english.path).should == "I like dogs."
-        File.read(converted_path).should == "I like 犬.\n"
-      ensure
-        @dictionary.close!
-        @english.close!
-        File.delete converted_path
-      end
-    end
-
-    it "should return the name of the sub_command" do
-      CLI.start.should == :translate
+      CLI.start
+      converted_path = Utils.build_converted_file_name(@english.path, "en", "ja")
+      File.read(@english.path).should == "I like dogs."
+      File.read(converted_path).should == "I like 犬.\n"
     end
   end
 end

data/spec/dictionary_spec.rb

@@ -37,7 +37,7 @@ describe Dictionary do
 
   describe "when converting from English to Japanese" do
     before :each do
-      Dictionary.load "en", "ja", [@dictionary.path]
+      Dictionary.load "en", "ja", { :using => [@dictionary.path] }
     end
 
     it "should correctly load a simple term" do
@@ -68,7 +68,7 @@ describe Dictionary do
 
   describe "when converting from Japanese to English" do
     before :each do
-      Dictionary.load "ja", "en", [@dictionary.path]
+      Dictionary.load "ja", "en", { :using => [@dictionary.path] }
     end
 
     it "should add whitespace to term replacement" do
@@ -78,7 +78,7 @@ describe Dictionary do
 
   describe "when converting from English to Spanish" do
     before :each do
-      Dictionary.load "en", "es", [@dictionary.path]
+      Dictionary.load "en", "es", { :using => [@dictionary.path] }
     end
 
     it "should not add whitespace to term replacement" do

data/spec/language_spec.rb

@@ -6,6 +6,12 @@ describe Language do
     Language.find(:eng).should == :en
   end
 
+  it "should find French" do
+    Language.find(:french).should == :fr
+    Language.find(:fre).should == :fr
+    Language.find(:fra).should == :fr
+  end
+
   it "should find Japanese" do
     Language.find(:japanese).should == :ja
     Language.find(:jpn).should == :ja

data/spec/utils_spec.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + "/spec_helper"
+require "tempfile"
 
 describe Utils do
   it "should extract the correct language from a filename" do
@@ -10,4 +11,52 @@ describe Utils do
     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
+
+  describe "when forcing an extension" do
+    before :each do
+      @konjac = Tempfile.new(["test", ".konjac"])
+      @kon2   = Tempfile.new(["test2", ".konjac"])
+      @docx   = Tempfile.new(["test", ".docx"])
+      @doc2   = Tempfile.new(["test2", ".docx"])
+    end
+
+    it "should work when the user does not specify an extension" do
+      files_found = Utils.parse_files("#{Dir.tmpdir}/*", ".konjac")
+      files_found.should include @konjac.path
+      files_found.should include @kon2.path
+      files_found.should_not include @docx.path
+      files_found.should_not include @doc2.path
+      files_found = Utils.parse_files("#{Dir.tmpdir}/*", ".docx")
+      files_found.should include @docx.path
+      files_found.should include @doc2.path
+      files_found.should_not include @konjac.path
+      files_found.should_not include @kon2.path
+    end
+
+    it "should work when the user does specify an extension" do
+      files_found = Utils.parse_files("#{Dir.tmpdir}/*.docx", ".konjac")
+      files_found.should include @konjac.path
+      files_found.should include @kon2.path
+      files_found.should_not include @docx.path
+      files_found.should_not include @doc2.path
+      files_found = Utils.parse_files("#{Dir.tmpdir}/*.docx", ".docx")
+      files_found.should include @docx.path
+      files_found.should include @doc2.path
+      files_found.should_not include @konjac.path
+      files_found.should_not include @kon2.path
+    end
+
+    it "should work when the user supplies wildcards" do
+      files_found = Utils.parse_files("#{Dir.tmpdir}/*.*", ".konjac")
+      files_found.should include @konjac.path
+      files_found.should include @kon2.path
+      files_found.should_not include @docx.path
+      files_found.should_not include @doc2.path
+      files_found = Utils.parse_files("#{Dir.tmpdir}/*.*", ".docx")
+      files_found.should include @docx.path
+      files_found.should include @doc2.path
+      files_found.should_not include @konjac.path
+      files_found.should_not include @kon2.path
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konjac
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-13 00:00:00.000000000 Z
+date: 2012-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &70265140795800 !ruby/object:Gem::Requirement
+  requirement: &70250662109380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,32 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70265140795800
+  version_requirements: *70250662109380
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &70265140794440 !ruby/object:Gem::Requirement
+  name: term-ansicolor
+  requirement: &70250662108960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70250662108960
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &70250662108540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70250662108540
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: &70250662124620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70265140794440
+  version_requirements: *70250662124620
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &70265140793660 !ruby/object:Gem::Requirement
+  name: autotest-fsevent
+  requirement: &70250662124060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70265140793660
+  version_requirements: *70250662124060
 - !ruby/object:Gem::Dependency
-  name: sdoc
-  requirement: &70265140792780 !ruby/object:Gem::Requirement
+  name: autotest-growl
+  requirement: &70250662123300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70265140792780
+  version_requirements: *70250662123300
 - !ruby/object:Gem::Dependency
-  name: autotest
-  requirement: &70265140791700 !ruby/object:Gem::Requirement
+  name: bundler
+  requirement: &70250662122840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70265140791700
+  version_requirements: *70250662122840
 - !ruby/object:Gem::Dependency
-  name: autotest-fsevent
-  requirement: &70265140790860 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: &70250662122420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70265140790860
+  version_requirements: *70250662122420
 - !ruby/object:Gem::Dependency
-  name: autotest-growl
-  requirement: &70265140789760 !ruby/object:Gem::Requirement
+  name: sdoc
+  requirement: &70250662121920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,7 +109,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70265140789760
+  version_requirements: *70250662121920
 description: A Ruby command-line utility for translating files using a YAML wordlist
 email:
 - bryan.mckelvey@gmail.com
@@ -107,8 +129,6 @@ files:
 - konjac.gemspec
 - lib/konjac.rb
 - lib/konjac/cli.rb
-- lib/konjac/cli/sub_command.rb
-- lib/konjac/cli/sub_command_manager.rb
 - lib/konjac/dictionary.rb
 - lib/konjac/exception.rb
 - lib/konjac/language.rb

data/lib/konjac/cli/sub_command.rb

@@ -1,20 +0,0 @@
-module Konjac
-  module CLI
-    class SubCommand
-      attr :name, :aliases, :description
-
-      def initialize(name, aliases, description, &block)
-        @name, @aliases, @description = name, aliases, description
-        @block = block
-      end
-
-      def alias_text
-        @aliases.join ", "
-      end
-
-      def execute
-        @block.call
-      end
-    end
-  end
-end

data/lib/konjac/cli/sub_command_manager.rb

@@ -1,77 +0,0 @@
-module Konjac
-  module CLI
-    class SubCommandManager
-      def initialize
-        @sub_commands ||= []
-      end
-
-      def add(name, aliases, description, &block)
-        @sub_commands << SubCommand.new(name, aliases, description, &block)
-      end
-
-      def execute(sub_command)
-        sub_command = sub_command.to_sym
-
-        @sub_commands.each do |sc|
-          if sc.name == sub_command || sc.aliases.include?(sub_command)
-            sc.execute
-            return sc.name
-          end
-        end
-
-        return nil
-      end
-
-      def all
-        @sub_commands
-      end
-
-      def get_lengths
-        @lengths = { :name => 8, :aliases => 7, :description => 11 }
-
-        @sub_commands.each do |sc|
-          if sc.name.length > @lengths[:name]
-            @lengths[:name] = sc.name.length
-          end
-          if sc.alias_text.length > @lengths[:aliases]
-            @lengths[:aliases] = sc.alias_text.length
-          end
-          if sc.description.length > @lengths[:description]
-            @lengths[:description] = sc.description.length
-          end
-        end
-      end
-
-      def to_s
-        get_lengths
-        text = "\n"
-
-        header_lines = "%s  %s  %s\n" % [
-          "-" * @lengths[:name],
-          "-" * @lengths[:aliases],
-          "-" * @lengths[:description]
-        ]
-
-        # Create headers
-        text << header_lines
-        text << "%s  %s  %s\n" % [
-          "Commands".ljust(@lengths[:name]),
-          "Aliases".ljust(@lengths[:aliases]),
-          "Description".ljust(@lengths[:description])
-        ]
-        text << header_lines
-
-        # Write descriptions of each subcommand
-        @sub_commands.each do |sc|
-          text << "%s  %s  %s\n" % [
-            sc.name.to_s.ljust(@lengths[:name]),
-            sc.alias_text.to_s.ljust(@lengths[:aliases]),
-            sc.description.to_s.ljust(@lengths[:description])
-          ]
-        end
-
-        text
-      end
-    end
-  end
-end