konjac 0.2.9.5 → 0.3

data/konjac.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "highline"
   s.add_runtime_dependency "i18n"
   s.add_runtime_dependency "nokogiri"
+  s.add_runtime_dependency "rb-appscript"
   s.add_runtime_dependency "sdoc"
   s.add_runtime_dependency "term-ansicolor"
   s.add_runtime_dependency "trollop"

data/lib/konjac.rb

@@ -18,10 +18,7 @@ module Konjac
   autoload :Installer,  "konjac/installer"
   autoload :Language,   "konjac/language"
   autoload :Office,     "konjac/office"
-  autoload :OS,         "konjac/os"
   autoload :Suggestor,  "konjac/suggestor"
-  autoload :Tag,        "konjac/tag"
-  autoload :TagManager, "konjac/tag_manager"
   autoload :Translator, "konjac/translator"
   autoload :Utils,      "konjac/utils"
 

data/lib/konjac/cli.rb

@@ -80,7 +80,7 @@ eos
                 :default => Config.dictionary, :multi => true
               opt :help, I18n.t(:help, :scope => :opts)
             end
-            Office.export_tags ARGV, opts
+            Office.new(ARGV[0]).export
           when "exportxml"
             opts = Trollop::options do
               banner sc_banner % I18n.t(:filenames_arg)
@@ -100,7 +100,7 @@ eos
               opt :output, I18n.t(:output, :scope => :opts), :type => :string
               opt :help, I18n.t(:help, :scope => :opts)
             end
-            Office.import_tags ARGV, opts
+            Office.new(ARGV[0]).import
           when "importxml"
             opts = Trollop::options do
               banner sc_banner % I18n.t(:filenames_arg)

data/lib/konjac/exception.rb

@@ -5,4 +5,7 @@ module Konjac
   # The user has supplied an invalid language and Konjac can't continue to
   # process the request
   class InvalidLanguageError < StandardError; end
+
+  # The user has requested an unimplemented virtual method
+  class VirtualMethodError < StandardError; end
 end

data/lib/konjac/office.rb

@@ -1,283 +1,90 @@
 module Konjac
   # A singleton for dealing with extracting and importing tags from Microsoft
-  # Office documents
+  # Office documents. It also has abstract some of the lengthier calls to the
+  # different applications of different environments by detecting the user's
+  # operating system and using ghost methods. For example, the following are
+  # equivalent for opening the document at <tt>~/text.doc</tt> on a Mac:
+  #
+  #   doc = Konjac::Office::Mac::Word.new("~/text.doc")
+  #   doc = Konjac::Office.word("~/text.doc")
+  #
+  # In addition, if the document is already open and is the active document, the
+  # following will work too:
+  #
+  #   doc = Konjac::Office.word
   module Office
-    class << self
-      # Imports the text content of a tag file into a Microsoft Office document
-      def import_tags(files, opts = {})
-        sub_files = Utils.parse_files(files)
-        return if sub_files.empty?
-        sub_files.each do |sub_file|
-          case File.extname(sub_file)
-          when ".doc", ".docx"
-            return if OS.not_a_mac
-            system File.join(File.dirname(__FILE__), "..", "applescripts", "konjac_word_import"), sub_file
-          when ".ppt", ".pptx"
-            return if OS.not_a_mac
-            system File.join(File.dirname(__FILE__), "..", "applescripts", "konjac_powerpoint_import"), sub_file
-          when ".xls", ".xlsx"
-            return if OS.not_a_mac
-            system File.join(File.dirname(__FILE__), "..", "applescripts", "konjac_excel_import"), sub_file
-          else
-            puts I18n.t(:unknown) % sub_file
-          end
-        end
-      end
-
-      # Imports the text content of a tag file into a Word 2003+, utilizing a
-      # cleaned-up version of the document's original XML structure
-      def import_xml(files, opts = {})
-        sub_files = Utils.parse_files(files)
-        return if sub_files.empty?
-        sub_files.each do |sub_file|
-          case File.extname(sub_file)
-          when ".docx"
-            # 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}.docx.diff"
-            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)
+    autoload :Generic,   "konjac/office/generic"
+    autoload :Mac,       "konjac/office/mac"
+    autoload :OS,        "konjac/office/os"
+    autoload :Tag,       "konjac/office/tag"
+    autoload :Windows,   "konjac/office/windows"
+    autoload :XML,       "konjac/office/windows"
 
-            # 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
-
-            # 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
-
-            # Add the new document XML to the copied file
-            system "cd #{dirname} && zip -q #{new_path} word/document.xml"
-          else
-            puts I18n.t(:unknown) % sub_file
-          end
-        end
-      end
-
-      # Exports the text content of Microsoft Office document
-      def export_tags(files, opts = {})
-        # Determine whether to attempt translating
-        if opts[:from_given] && opts[:to_given]
-          from_lang = Language.find(opts[:from])
-          to_lang   = Language.find(opts[:to])
-          unless from_lang.nil? || to_lang.nil?
-            Translator.load_dictionary from_lang, to_lang, opts
-            attempting_to_translate = true
-          end
-        end
-
-        sub_files = Utils.parse_files(files)
-        return if sub_files.empty?
-        sub_files.each do |sub_file|
-          case File.extname(sub_file)
-          when ".doc", ".docx"
-            return if OS.not_a_mac
-            break unless Utils.user_allows_overwrite?(sub_file + ".diff")
-
-            system File.join(File.dirname(__FILE__), "..", "applescripts", "konjac_word_export"), sub_file
-          when ".ppt", ".pptx"
-            return if OS.not_a_mac
-            break unless Utils.user_allows_overwrite?(sub_file + ".diff")
-
-            system File.join(File.dirname(__FILE__), "..", "applescripts", "konjac_powerpoint_export"), sub_file
-          when ".xls", ".xlsx"
-            return if OS.not_a_mac
-            break unless Utils.user_allows_overwrite?(sub_file + ".diff")
-
-            system File.join(File.dirname(__FILE__), "..", "applescripts", "konjac_excel_export"), sub_file
-          else
-            puts I18n.t(:unknown) % sub_file
-          end
+    class << self
+      def new(path)
+        env = environment
+        return nil if env.nil?
+
+        case File.basename(path)
+        when /\.docx?/
+          env::Word.new(path)
+        when /\.pptx?/
+          env::PowerPoint.new(path)
+        when /\.xlsx?/
+          env::Excel.new(path)
         end
       end
 
-      # Exports the Word document in XML then extracts the tags and condenses
-      # like paragraphs
-      #
-      # I might deprecate this, but it exports XML. It's much faster, but
-      # supporting two methods might not be a great idea.
-      def export_xml(files, opts = {})
-        # Determine whether to attempt translating
-        if opts[:from_given] && opts[:to_given]
-          from_lang = Language.find(opts[:from])
-          to_lang   = Language.find(opts[:to])
-          unless from_lang.nil? || to_lang.nil?
-            Translator.load_dictionary from_lang, to_lang, opts
-            attempting_to_translate = true
-          end
-        end
-
-        sub_files = Utils.parse_files(files)
-        return if sub_files.empty?
-        sub_files.each do |sub_file|
-          case File.extname(sub_file)
-          when ".docx"
-            # 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}.docx.diff"
-
-            break unless Utils.user_allows_overwrite?(tags_path)
-
-            # 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
-                end
-                
-                prev = node
-              end
-
-              # Write the tags file
-              tags_file.puts "---" + orig_docx
-              tags_file.puts "+++" + orig_docx
-              cleaner.xpath("//w:t").each_with_index do |node, index|
-                tags_file.puts "@@ %i @@" % [index, additional_info(node)]
-                tags_file.puts "-" + node.content
-                if attempting_to_translate
-                  tags_file.puts "+" + Translator.translate_content(node.content)
-                else
-                  tags_file.puts "+" + node.content
-                end
-              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
-          else
-            puts I18n.t(:unknown) % sub_file
-          end
+      def environment
+        if OS.mac?
+          Mac
+        elsif OS.windows?
+          Windows
+        else
+          nil 
         end
       end
 
       private
 
-      # Performs a comparison between two nodes and accepts them as equivalent
-      # if the differences are very minor
-      def compare_nodes(a, b)  # :doc:
-        c = clean_hash(xml_node_to_hash(a))
-        d = clean_hash(xml_node_to_hash(b))
-        c == d
-      end
-
-      # Converts an XML node into a Ruby hash
-      def xml_node_to_hash(node)  # :doc:
-        # If we are at the root of the document, start the hash
-        if node.element?
-          result_hash = {}
-          if node.attributes != {}
-            result_hash[:attributes] = {}
-            node.attributes.keys.each do |key|
-              result_hash[:attributes][node.attributes[key].name.to_sym] = prepare(node.attributes[key].value)
-            end
-          end
-          if node.children.size > 0
-            node.children.each do |child|
-              result = xml_node_to_hash(child)
-
-              if child.name == "text"
-                unless child.next_sibling || child.previous_sibling
-                  return prepare(result)
-                end
-              elsif result_hash[child.name.to_sym]
-                if result_hash[child.name.to_sym].is_a?(Array)
-                  result_hash[child.name.to_sym] << prepare(result)
-                else
-                  result_hash[child.name.to_sym] = [result_hash[child.name.to_sym]] << prepare(result)
-                end
-              else
-                result_hash[child.name.to_sym] = prepare(result)
-              end
-            end
-
-            return result_hash
-          else
-            return result_hash
-          end
+      def method_missing(name, *args, &block)
+        env = environment
+        return super if env.nil?
+        index = env.constants.index(camelize(name).to_sym)
+        if index.nil?
+          super
         else
-          return prepare(node.content.to_s)
+          env.const_get(env.constants[index]).new *args
         end
       end
 
-      # Prepares data according to whether it's string or integer content
-      def prepare(data)  # :doc:
-        (data.class == String && data.to_i.to_s == data) ? data.to_i : data
-      end
+      def valid_environments
+        return @environments unless @environments.nil?
 
-      # Delete extraneous attributes for comparison
-      def clean_hash(hash)  # :doc:
-        delete_attribute_or_child hash, :t
-        delete_attribute_or_child hash, :rPr, :rFonts, :attributes, :hint
-      end
+        @environments = []
+        downcased = constants.map { |c| underscore(c.to_s) }
+        Dir.glob(File.join(File.dirname(File.expand_path(__FILE__)), "office/*/")).each do |dir|
+          index = downcased.index(dir.split("/").last)
+          @environments << constants[index] unless index.nil?
+        end
 
-      # Get additional information on the node for context in tags file
-      def additional_info(node)  # :doc:
-        info = []
-        info << "hyperlink" if node.parent.parent.name == "hyperlink"
+        @environments
+      end
 
-        if info.empty?
-          ""
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
         else
-          "  #=> #{info.join(", ")}"
+          lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
         end
       end
 
-      # Deletes the specified attribute or child node for the supplied node,
-      # following the hierarchy provided
-      #
-      # Delete <tt>hash[:rPr][:rFonts][:attributes][:hint]</tt>:
-      #   delete_attribute_or_child hash, :rPr, :rFonts, :attributes, :hint
-      def delete_attribute_or_child(node, *hierarchy)  # :doc:
-        last_member = hierarchy.pop
-        
-        hierarchy.each do |member|
-          node = node[member] unless node.nil?
-        end
-
-        node.delete last_member unless node.nil?
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
       end
     end
   end

data/lib/konjac/office/generic.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+module Konjac
+  module Office
+    # This is a basic class that contains all the methods that are universal
+    # across OSes, file formats, applications, etc.
+    class Generic
+      attr_reader :document, :index, :current
+
+      def initialize(location = nil)
+        @document = open(File.expand_path(location)) unless location.nil?
+        @document = active_document
+        @index = 0
+        @current = nil
+      end
+
+      # This only does the bare minimum, extracting arguments from
+      # <tt>*args</tt>, so that subclass methods have their parameters parsed
+      def write(text, *args)
+        parse_args *args
+      end
+
+      def read(*args)
+        opts = parse_args(*args)
+        clean find(opts), (opts.nil? ? nil : opts[:type])
+      end
+
+      def tags
+        Tag.load path
+      end
+
+      def export
+        Tag.dump data, path
+      end
+
+      def import
+        tags.each do |tag|
+          if tag.changed? && !tag.blank?
+            write tag.added.join(delimiter(tag.type)), *tag.indices,
+              :type => tag.type
+          end
+        end
+      end
+
+      def delimiter(type)
+        if type.nil?
+          "\v"
+        else
+          case type
+          when :shape
+            "\r"
+          else
+            "\n"
+          end
+        end
+      end
+
+      private
+
+      def parse_args(*args)
+        return nil if args.empty? || args.nil?
+
+        # Extract final argument if it's a hash
+        parsed = args.last.is_a?(Hash) ? args.pop : {}
+
+        # Create hash using @parse_order as keys and args as values, then merge
+        # that with any pre-parsed hashes. Arguments specified via the hash have
+        # priority
+        parsed = Hash[@parse_order.zip(args)].merge(parsed)
+      end
+
+      def clean(text, type = nil)
+        text.gsub(@strippable, "").split delimiter(type)
+      end
+    end
+  end
+end