konjac 0.2.9.5 → 0.3

data/lib/konjac/office/mac.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+module Konjac
+  module Office
+    module Mac
+      autoload :Excel,      "konjac/office/mac/excel"
+      autoload :PowerPoint, "konjac/office/mac/power_point"
+      autoload :Shared,     "konjac/office/mac/shared"
+      autoload :Word,       "konjac/office/mac/word"
+    end
+  end
+end

data/lib/konjac/office/mac/excel.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+module Konjac
+  module Office
+    module Mac
+      class Excel < Shared
+        def initialize(path = nil)
+          super "Microsoft Excel", path
+          @strippable = //
+          @delimiter = "\r"
+          @parse_order = [:sheet, :row, :cell]
+          find 1, 1, 1
+        end
+
+        # Retrieves the active document and caches it
+        def active_document
+          @active_document ||= @application.active_workbook
+        end
+
+        def write(text, *args)
+          if args.empty?
+            @current.formula.set text
+          else
+            opts = parse_args(*args)
+            @document.sheets[opts[:sheet]]
+                     .rows[opts[:row]]
+                     .cells[opts[:cell]].formula.set text
+          end
+        end
+
+        # Creates a dump of the spreadsheet's data in Tag form
+        def data
+          tags = []
+          @document.sheets.get.each_with_index do |sheet, s|
+            sheet.used_range.rows.get.each_with_index do |row, r|
+              row.cells.get.each_with_index do |cell, c|
+                temp = Tag.new
+                temp.indices = [s + 1, r + 1, c + 1]
+                temp.removed = temp.added = read(s + 1, r + 1, c + 1)
+                tags << temp unless temp.blank?
+              end
+            end
+          end
+          tags
+        end
+
+        # Finds the paragraph indicated by the provided index
+        def find(*args)
+          unless args.empty?
+            @indices = args
+            opts = parse_args(*args)
+            @current = @document.sheets[opts[:sheet]]
+                                .rows[opts[:row]]
+                                .cells[opts[:cell]]
+          end
+
+          @current.formula.get
+        end
+
+        # Retrieves the number of cells in the document. Note that this method
+        # fetches all row and column elements and can thus be very expensive for
+        # large spreadsheets.
+        def size
+          @document.sheets.inject(0) do |result, sheet|
+            range   = sheet.used_range 
+            result += range.rows.get.size * range.columns.get.size
+          end
+        end
+        alias :length :size
+      end
+    end
+  end
+end
+

data/lib/konjac/office/mac/power_point.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+module Konjac
+  module Office
+    module Mac
+      class PowerPoint < Shared
+        def initialize(path = nil)
+          super "Microsoft PowerPoint", path
+          @strippable = //
+          @delimiter = "\r"
+          @parse_order = [:slide, :shape]
+          find 1, 1
+        end
+
+        # Retrieves the active document and caches it
+        def active_document
+          @active_document ||= @application.active_presentation
+        end
+
+        def write(text, *args)
+          if args.empty?
+            @current.text_frame.text_range.content.set text
+          else
+            opts = parse_args(*args)
+            @document.slides[opts[:slide]]
+                     .shapes[opts[:shape]].text_frame.text_range.content.set text
+          end
+        end
+
+        # Creates a dump of the spreadsheet's data in Tag form
+        def data
+          tags = []
+          @document.slides.get.each_with_index do |slide, sl|
+            slide.shapes.get.each_with_index do |shape, sh|
+              temp = Tag.new
+              temp.indices = [sl + 1, sh + 1]
+              temp.removed = temp.added = read(sl + 1, sh + 1)
+              tags << temp unless temp.blank?
+            end
+          end
+          tags
+        end
+
+        # Finds the paragraph indicated by the provided index
+        def find(*args)
+          unless args.empty?
+            @indices = args
+            opts = parse_args(*args)
+            @current = @document.slides[opts[:slide]]
+                                .shapes[opts[:shape]]
+          end
+
+          @current.text_frame.text_range.content.get
+        end
+
+        # Retrieves the number of cells in the document. Note that this method
+        # fetches all row and column elements and can thus be very expensive for
+        # large spreadsheets.
+        def size
+        end
+        alias :length :size
+
+        def delimiter(type = nil)
+          "\r"
+        end
+      end
+    end
+  end
+end

data/lib/konjac/office/mac/shared.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+require "appscript"
+
+module Konjac
+  module Office
+    module Mac
+      class Shared < Generic
+        def initialize(app_name, path = nil)
+          @application = Appscript.app(app_name)
+          super path
+        end
+
+        def open(path)
+          @application.open path
+        end
+        
+        # Retrieves the POSIX path of the document
+        def path
+          @path ||= posix_path(@document.full_name.get)
+        end
+
+        private
+
+        # Converts an HFS (Mac) path to a POSIX path
+        def posix_path(hfs_path)
+          %x[osascript -e 'POSIX path of "#{hfs_path}"'].chomp
+        end
+
+        # Converts a POSIX path to an HFS (Mac) path
+        def hfs_path(posix_path)
+          %x[osascript -e '(POSIX file "#{posix_path}") as string'].chomp
+        end
+      end
+    end
+  end
+end

data/lib/konjac/office/mac/word.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+module Konjac
+  module Office
+    module Mac
+      class Word < Shared
+        def initialize(path = nil)
+          super "Microsoft Word", path
+          @strippable = /[\r\n\a]+$/
+          @index = 1
+          @current = @document.paragraphs[@index]
+          @parse_order = [:paragraph]
+        end
+
+        # Retrieves the active document and caches it
+        def active_document
+          @active_document ||= @application.active_document
+        end
+
+        def write(text, *args)
+          opts = super(text, *args)
+          if opts[:type].nil? || opts[:type].empty?
+            select opts
+            @application.selection.type_text :text => text
+          else
+            @document.shapes[opts[:paragraph]].text_frame.text_range.content.set text
+          end
+        end
+
+        # Creates a dump of the document's data in Tag form
+        def data
+          @index = 1
+          @current = @document.paragraphs[@index]
+
+          tags = []
+
+          # An open-ended loop is necessary because requesting a paragraphs
+          # enumerator will retrieve all paragraphs from the document,
+          # potentially consuming a large amount of memory and freezing Word
+          loop do
+            temp = Tag.new
+            temp.indices = [@index]
+            temp.removed = temp.added = read
+            tags << temp unless temp.blank?
+            break if succ.nil?
+          end
+
+          # TODO: I should optimize this later like above, to prevent large
+          # shapes from getting out of hand
+          @document.shapes.get.each_with_index do |shape, index|
+            temp = Tag.new
+            temp.indices = [index + 1]
+            temp.removed = temp.added =
+              clean(shape.text_frame.text_range.content.get)
+            temp.type = :shape
+            tags << temp unless temp.blank?
+          end
+
+          tags
+        end
+
+        # Finds the paragraph indicated by the provided index
+        def find(*args)
+          unless args.empty? || args.nil?
+            opts = parse_args(*args)
+            if (opts[:type].nil? || opts[:type].empty?) && !opts[:paragraph].nil?
+              @index   = opts[:paragraph]
+              @current = @document.paragraphs[opts[:paragraph]]
+            elsif opts[:type] == :shape
+              return @document.shapes[opts[:paragraph]].text_frame.text_range.content.get
+            end
+          end
+
+          @current.text_object.content.get
+        end
+
+        # Retrieves the number of paragraphs in the document. Note that this
+        # method fetches all paragraphs elements and can thus be very expensive
+        # for large documents.
+        def size
+          @document.paragraphs.get.size
+        end
+        alias :length :size
+
+        # Goes to the next paragraph
+        def succ
+          @index  += 1
+          @current = @current.next_paragraph
+        rescue
+          @index  -= 1
+          nil
+        end
+        alias :next :succ
+
+        # Selects the paragraph indicated by an indicated, or +nil+ to select
+        # the current paragraph
+        def select(*args)
+          opts = parse_args(*args)
+          find opts
+          para_start = @current.text_object.start_of_content.get
+          para_end   = @current.text_object.end_of_content.get
+          range      = active_document.create_range(:start => para_start,
+                                                    :end_ => para_end)
+
+          # Move in end of range by length of stripped content less end of table
+          # mark
+          strip_size = range.content.get[@strippable].gsub(/\a/, "").size
+          range      = active_document.create_range(:start => para_start,
+                                                    :end_ => para_end - strip_size)
+          range.select
+        end
+      end
+    end
+  end
+end

data/lib/konjac/office/os.rb

@@ -0,0 +1,53 @@
+module Konjac
+  module Office
+    # A module for determining what OS we're using
+    module OS
+      class << self
+        # Override string output
+        def to_s
+          RbConfig::CONFIG["host_os"]
+        end
+
+        # OS is a version of Mac
+        def mac?
+          @mac ||= is? /mac|darwin/
+        end
+        
+        # OS is a version of Linux
+        def linux?
+          @linux ||= is? /linux|cygwin/
+        end
+
+        # OS is a version of Windows
+        def windows?
+          @windows ||= is? /mswin|^win|mingw/
+        end
+
+        # OS is POSIX (well, actually, this makes the somewhat bad assumption
+        # that non-Windows OSes are POSIX)
+        def posix?
+          !windows?
+        end
+
+        # Throws a message if the computer is using a command restricted to Macs
+        def not_a_mac
+          if mac?
+            return false
+          else
+            puts I18n.t(:mac_only)
+            return true
+          end
+        end
+
+
+        private
+
+        # Test whether the +host_os+ configuration parameter matches a specified
+        # regular expression
+        def is?(match)
+          match === RbConfig::CONFIG["host_os"]
+        end
+      end
+    end
+  end
+end

data/lib/konjac/office/tag.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+module Konjac
+  module Office
+    class Tag
+      attr_accessor :indices, :removed, :added, :type
+
+      def initialize
+        @indices = nil
+        @removed = []
+        @added   = []
+        @type    = nil
+      end
+
+      # Whether the tag has changed content
+      def changed?
+        @removed != @added
+      end
+
+      # Determines whether the tag is blank, that is, if it has no +indices+ or
+      # both +removed+ and +added+ are empty
+      def blank?
+        @indices.nil? || (@removed.join.empty? && @added.join.empty?)
+      end
+
+      # Converts the tag to a string
+      def to_s
+        <<-eos
+@@ #{@type.nil? ? "" : "#{@type} "}#{@indices.join(",")} @@
+-#{@removed.join("\n-")}
++#{@added.join("\n+")}
+        eos
+      end
+
+      # Whether the tag's content if for the default kind of object
+      def default?
+        @type.nil?
+      end
+
+      # Whether the tag's content if for a special kind of object
+      def special?
+        !!@type
+      end
+
+      class << self
+        TAG_MATCHES = {
+          :header  => /^(?:---|\+\+\+)/,
+          :comment => /^\@\@ ([a-z]*) ?([\d, ]+) \@\@$/i,
+          :removed => /^-(.*)/,
+          :added   => /^\+(.*)/,
+        }
+
+        # Loads the tags for the specified document path or the tags file itself
+        def load(path)
+          tags = []
+          temp = Tag.new
+          File.read("#{path.sub(/\.diff$/, "")}.diff").each_line do |line|
+            case line
+            when TAG_MATCHES[:header]
+            when TAG_MATCHES[:comment]
+              unless temp.blank?
+                tags << temp
+                temp = Tag.new
+              end
+              temp.type    = $1.to_sym unless $1.nil?
+              temp.indices = $2.scan(/\d+/).map(&:to_i)  # this changes $~
+            when TAG_MATCHES[:removed]
+              temp.removed << $1
+            when TAG_MATCHES[:added]
+              temp.added << $1
+            end
+          end
+          tags << temp unless temp.blank?
+          tags
+        end
+
+        def dump(tags, path, opts = {})
+          original_path = path.sub(/\.diff$/, "")
+          diff_path     = "#{original_path}.diff"
+          
+          File.open(diff_path, "w") do |file|
+            file.puts "--- #{original_path}"
+            file.puts "+++ #{original_path}"
+            tags.each do |tag|
+              file.puts tag.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end