CommandWrap 0.1

data/README

@@ -0,0 +1,18 @@
+A set of utility classes to extract meta data from different file types
+
+INSTALL
+-------
+
+gem install fileutils
+
+REQUIREMENTS
+------------
+
+For full functionality the following programs must be installed:
+- openoffice
+- openoffice python bindings
+- pdftk
+- zip
+- imagemagick
+- Xvfb
+- libqt-webkit, libqt4-svg

data/bin/DocumentConverter.py

@@ -0,0 +1,231 @@
+#
+# PyODConverter (Python OpenDocument Converter) v1.1 - 2009-11-14
+#
+# This script converts a document from one office format to another by
+# connecting to an OpenOffice.org instance via Python-UNO bridge.
+#
+# Copyright (C) 2008-2009 Mirko Nasato <mirko@artofsolving.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl-2.1.html
+# - or any later version.
+#
+DEFAULT_OPENOFFICE_PORT = 8100
+
+import uno
+from os.path import abspath, isfile, splitext
+from com.sun.star.beans import PropertyValue
+from com.sun.star.task import ErrorCodeIOException
+from com.sun.star.connection import NoConnectException
+
+FAMILY_TEXT = "Text"
+FAMILY_WEB = "Web"
+FAMILY_SPREADSHEET = "Spreadsheet"
+FAMILY_PRESENTATION = "Presentation"
+FAMILY_DRAWING = "Drawing"
+
+#---------------------#
+# Configuration Start #
+#---------------------#
+
+# see http://wiki.services.openoffice.org/wiki/Framework/Article/Filter
+
+# most formats are auto-detected; only those requiring options are defined here
+IMPORT_FILTER_MAP = {
+    "txt": {
+        "FilterName": "Text (encoded)",
+        "FilterOptions": "utf8"
+    },
+    "csv": {
+        "FilterName": "Text - txt - csv (StarCalc)",
+        "FilterOptions": "44,34,0"
+    }
+}
+
+EXPORT_FILTER_MAP = {
+    "pdf": {
+        FAMILY_TEXT: { "FilterName": "writer_pdf_Export" },
+        FAMILY_WEB: { "FilterName": "writer_web_pdf_Export" },
+        FAMILY_SPREADSHEET: { "FilterName": "calc_pdf_Export" },
+        FAMILY_PRESENTATION: { "FilterName": "impress_pdf_Export" },
+        FAMILY_DRAWING: { "FilterName": "draw_pdf_Export" }
+    },
+    "html": {
+        FAMILY_TEXT: { "FilterName": "HTML (StarWriter)" },
+        FAMILY_SPREADSHEET: { "FilterName": "HTML (StarCalc)" },
+        FAMILY_PRESENTATION: { "FilterName": "impress_html_Export" }
+    },
+    "odt": {
+        FAMILY_TEXT: { "FilterName": "writer8" },
+        FAMILY_WEB: { "FilterName": "writerweb8_writer" }
+    },
+    "doc": {
+        FAMILY_TEXT: { "FilterName": "MS Word 97" }
+    },
+    "rtf": {
+        FAMILY_TEXT: { "FilterName": "Rich Text Format" }
+    },
+    "txt": {
+        FAMILY_TEXT: {
+            "FilterName": "Text",
+            "FilterOptions": "utf8"
+        }
+    },
+    "ods": {
+        FAMILY_SPREADSHEET: { "FilterName": "calc8" }
+    },
+    "xls": {
+        FAMILY_SPREADSHEET: { "FilterName": "MS Excel 97" }
+    },
+    "csv": {
+        FAMILY_SPREADSHEET: {
+            "FilterName": "Text - txt - csv (StarCalc)",
+            "FilterOptions": "44,34,0"
+        }
+    },
+    "odp": {
+        FAMILY_PRESENTATION: { "FilterName": "impress8" }
+    },
+    "ppt": {
+        FAMILY_PRESENTATION: { "FilterName": "MS PowerPoint 97" }
+    },
+    "swf": {
+        FAMILY_DRAWING: { "FilterName": "draw_flash_Export" },
+        FAMILY_PRESENTATION: { "FilterName": "impress_flash_Export" }
+    }
+}
+
+PAGE_STYLE_OVERRIDE_PROPERTIES = {
+    FAMILY_SPREADSHEET: {
+        #--- Scale options: uncomment 1 of the 3 ---
+        # a) 'Reduce / enlarge printout': 'Scaling factor'
+        "PageScale": 100,
+        # b) 'Fit print range(s) to width / height': 'Width in pages' and 'Height in pages'
+        #"ScaleToPagesX": 1, "ScaleToPagesY": 1000,
+        # c) 'Fit print range(s) on number of pages': 'Fit print range(s) on number of pages'
+        #"ScaleToPages": 1,
+        "PrintGrid": False
+    }
+}
+
+#-------------------#
+# Configuration End #
+#-------------------#
+
+class DocumentConversionException(Exception):
+
+    def __init__(self, message):
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+
+class DocumentConverter:
+    
+    def __init__(self, port=DEFAULT_OPENOFFICE_PORT):
+        localContext = uno.getComponentContext()
+        resolver = localContext.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", localContext)
+        try:
+            context = resolver.resolve("uno:socket,host=localhost,port=%s;urp;StarOffice.ComponentContext" % port)
+        except NoConnectException:
+            raise DocumentConversionException, "failed to connect to OpenOffice.org on port %s" % port
+        self.desktop = context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", context)
+
+    def convert(self, inputFile, outputFile):
+
+        inputUrl = self._toFileUrl(inputFile)
+        outputUrl = self._toFileUrl(outputFile)
+
+        loadProperties = { "Hidden": True }
+        inputExt = self._getFileExt(inputFile)
+        if IMPORT_FILTER_MAP.has_key(inputExt):
+            loadProperties.update(IMPORT_FILTER_MAP[inputExt])
+        
+        document = self.desktop.loadComponentFromURL(inputUrl, "_blank", 0, self._toProperties(loadProperties))
+        try:
+            document.refresh()
+        except AttributeError:
+            pass
+
+        family = self._detectFamily(document)
+        self._overridePageStyleProperties(document, family)
+        
+        outputExt = self._getFileExt(outputFile)
+        storeProperties = self._getStoreProperties(document, outputExt)
+
+        try:
+            document.storeToURL(outputUrl, self._toProperties(storeProperties))
+        finally:
+            document.close(True)
+
+    def _overridePageStyleProperties(self, document, family):
+        if PAGE_STYLE_OVERRIDE_PROPERTIES.has_key(family):
+            properties = PAGE_STYLE_OVERRIDE_PROPERTIES[family]
+            pageStyles = document.getStyleFamilies().getByName('PageStyles')
+            for styleName in pageStyles.getElementNames():
+                pageStyle = pageStyles.getByName(styleName)
+                for name, value in properties.items():
+                    pageStyle.setPropertyValue(name, value)
+
+    def _getStoreProperties(self, document, outputExt):
+        family = self._detectFamily(document)
+        try:
+            propertiesByFamily = EXPORT_FILTER_MAP[outputExt]
+        except KeyError:
+            raise DocumentConversionException, "unknown output format: '%s'" % outputExt
+        try:
+            return propertiesByFamily[family]
+        except KeyError:
+            raise DocumentConversionException, "unsupported conversion: from '%s' to '%s'" % (family, outputExt)
+    
+    def _detectFamily(self, document):
+        if document.supportsService("com.sun.star.text.WebDocument"):
+            return FAMILY_WEB
+        if document.supportsService("com.sun.star.text.GenericTextDocument"):
+            # must be TextDocument or GlobalDocument
+            return FAMILY_TEXT
+        if document.supportsService("com.sun.star.sheet.SpreadsheetDocument"):
+            return FAMILY_SPREADSHEET
+        if document.supportsService("com.sun.star.presentation.PresentationDocument"):
+            return FAMILY_PRESENTATION
+        if document.supportsService("com.sun.star.drawing.DrawingDocument"):
+            return FAMILY_DRAWING
+        raise DocumentConversionException, "unknown document family: %s" % document
+
+    def _getFileExt(self, path):
+        ext = splitext(path)[1]
+        if ext is not None:
+            return ext[1:].lower()
+
+    def _toFileUrl(self, path):
+        return uno.systemPathToFileUrl(abspath(path))
+
+    def _toProperties(self, dict):
+        props = []
+        for key in dict:
+            prop = PropertyValue()
+            prop.Name = key
+            prop.Value = dict[key]
+            props.append(prop)
+        return tuple(props)
+
+
+if __name__ == "__main__":
+    from sys import argv, exit
+    
+    if len(argv) < 3:
+        print "USAGE: python %s <input-file> <output-file>" % argv[0]
+        exit(255)
+    if not isfile(argv[1]):
+        print "no such input file: %s" % argv[1]
+        exit(1)
+
+    try:
+        converter = DocumentConverter(argv[3])    
+        converter.convert(argv[1], argv[2])
+    except DocumentConversionException, exception:
+        print "ERROR! " + str(exception)
+        exit(1)
+    except ErrorCodeIOException, exception:
+        print "ERROR! ErrorCodeIOException %d" % exception.ErrCode
+        exit(1)
+

data/bin/openoffice_server.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require File.dirname(__FILE__) + "/../lib/command_wrap"
+
+CommandWrap::OpenOffice::Server.restart

data/lib/command_wrap.rb

@@ -0,0 +1,118 @@
+require 'RMagick'
+
+module CommandWrap
+        
+    # Creates a screenshot from the given url
+    # Uses CutyCapt (cutycapt.sourceforge.net)
+    def self.capture (url, target)
+        command = CommandWrap::Config::Xvfb.command(File.dirname(__FILE__) + "/../bin/CutyCapt --min-width=1024 --min-height=768 --url=#{url} --out=#{target}")
+        `#{command}`
+    end
+
+    # Sources consists of paths followed by the filename that must be used in the zip 
+    def self.zip (target, *sources)
+        targetdir = "#{CommandWrap::Config.tmp_dir}/zip"
+        id = 1
+        while File.exists?(targetdir)
+            targetdir = "#{CommandWrap::Config.tmp_dir}/zip#{id}"
+            id += 1
+        end
+        FileUtils.mkdir(targetdir)
+
+        path = ''
+        sources.each do |value|
+            if path == ''
+                path = value
+            else
+                FileUtils.copy(path, "#{targetdir}/#{value}")
+                path = ''
+            end
+        end
+
+        `#{CommandWrap::Config.zip} -j #{target} #{targetdir}/*`
+
+        FileUtils.rm_rf(targetdir)
+    end
+
+    def self.extension (filename)
+        return '' unless filename.include?('.')
+        filename.split('.').last
+    end
+
+    def self.preview (source, target, width, height)
+        extension = self.extension(source).upcase
+
+        # Image ?
+        formats = Magick.formats
+        if formats.key?(extension) && formats[extension].include?('r')
+            begin
+                CommandWrap::Image.scale(source, target, width, height)
+                return true
+            rescue
+                return false
+            end
+        end
+
+        tmppdf = self.temp('pdf')
+        tmppng = self.temp('png')
+        begin
+            # Create a pdf of the document
+            CommandWrap::OpenOffice.convert(source, tmppdf)
+            # Create a screenshot of first page of the generated pdf
+            CommandWrap::Pdf.preview(tmppdf, tmppng)
+            # Scale it down to thumb
+            CommandWrap::Image.scale(tmppng, target, width, height)
+            return true
+        rescue
+
+        ensure
+            # Cleanup
+            File.delete(tmppdf) if File.exists?(tmppdf) && File.writable?(tmppdf)
+            File.delete(tmppng) if File.exists?(tmppng) && File.writable?(tmppng)
+        end
+
+        nil
+    end
+
+    # Generates a temp filepath for the given extension
+    def self.temp (extension)
+        path = "#{CommandWrap::Config.tmp_dir}/tmp.#{extension}"
+        id = 1
+        while File.exists?(path)
+            path = "#{CommandWrap::Config.tmp_dir}/tmp.#{id}.#{extension}"
+            id += 1
+        end
+
+        path
+    end
+
+    # Tries to convert content of file to plaintext or html
+    def self.index (path)
+        extension = CommandWrap.extension(path).downcase
+
+        if extension == 'txt'
+            return IO.read(path)
+        end
+
+        if extension == 'html' || extension == 'htm'
+            return IO.read(path)
+        end
+
+        tmp = self.temp('html')
+        begin
+            CommandWrap::OpenOffice.convert(path, tmp)
+            return IO.read(tmp) if File.exists?(tmp)
+        rescue
+        ensure
+            File.delete(tmp) if File.exists?(tmp) && File.writable?(tmp)
+        end
+
+        ''
+    end
+
+    autoload :Image,        File.dirname(__FILE__) + "/command_wrap/image"
+    autoload :OpenOffice,   File.dirname(__FILE__) + "/command_wrap/open_office"
+    autoload :Config,       File.dirname(__FILE__) + "/command_wrap/config"
+    autoload :Pdf,          File.dirname(__FILE__) + "/command_wrap/pdf"
+
+end

data/lib/command_wrap/config.rb

@@ -0,0 +1,34 @@
+module CommandWrap
+
+    module Config
+
+        def self.tmp_dir
+            @tmp_dir ||= '/tmp'
+        end
+
+        def self.tmp_dir= (tmp_dir)
+            @tmp_dir = tmp_dir
+        end
+
+        def self.pdftk
+            @pdftk ||= 'pdftk'
+        end
+
+        def self.pdftk= (pdftk)
+            @pdftk = pdftk
+        end
+
+        def self.zip
+            @zip ||= 'zip'
+        end
+
+        def self.zip= (zip)
+            @zip = zip
+        end
+
+        autoload :OpenOffice,   File.dirname(__FILE__) + "/config/open_office"
+        autoload :Xvfb,         File.dirname(__FILE__) + "/config/xvfb"
+
+    end
+
+end

data/lib/command_wrap/config/open_office.rb

@@ -0,0 +1,79 @@
+module CommandWrap::Config
+
+    module OpenOffice
+
+        def self.command
+            "#{executable} #{parsed_params}"
+        end
+
+        def self.parsed_params
+            params.gsub('[port]', port.to_s).gsub('[host]', host)
+        end
+
+        def self.executable
+            @openoffice ||= "soffice"
+        end
+
+        def self.executable= (openoffice)
+            @openoffice = openoffice
+        end
+
+        def self.port
+            @port ||= 8000
+        end
+
+        def self.port= (port)
+            @port = port
+        end
+
+        def self.host
+            @host ||= "127.0.0.1"
+        end
+
+        def self.host= (host)
+             @host = host
+        end
+
+        def self.params
+            @params ||= '-headless -display :30 -accept="socket,host=[host],port=[port];urp;" -nofirststartwizard'
+        end
+
+        def self.params= (params)
+            @params = params
+        end
+
+        def self.xvfb
+            @xvfb ||= 'Xvfb :30 -screen 0 1024x768x24'
+        end
+
+        def self.xvfb= (xvfb)
+            @xvfb = xvfb
+        end
+
+        def self.stop_xvfb
+            @stop_xvfb ||= 'killall -9 Xvfb'
+        end
+
+        def self.stop_xvfb= (stop_xvfb)
+            @stop_xvfb = stop_xvfb
+        end
+
+        def self.stop
+            @stop ||= 'killall -9 soffice.bin'
+        end
+
+        def self.stop= (stop)
+            @stop = stop
+        end
+
+        def self.python
+            @python ||= 'python'
+        end
+
+        def self.python= (python)
+            @python = python
+        end
+
+    end
+
+end

data/lib/command_wrap/config/xvfb.rb

@@ -0,0 +1,27 @@
+module CommandWrap::Config
+
+    module Xvfb
+
+        def self.executable
+            @executable ||= "xvfb-run"
+        end
+
+        def self.executable= (executeable)
+            @executable = executeable
+        end
+
+        def self.params
+            @params ||= '--server-args="-screen 0, 1024x768x24"'
+        end
+
+        def self.params= (params)
+            @params = params
+        end
+
+        def self.command (subcommand)
+            "#{executable} #{params} #{subcommand}"
+        end
+
+    end
+
+end

data/lib/command_wrap/image.rb

@@ -0,0 +1,38 @@
+require 'RMagick'
+
+module CommandWrap
+
+    module Image
+
+        def self.dimensions (path)
+            img = Magick::Image.read(path)[0]
+            { :width => img.columns, :height => img.rows }
+        end
+
+        def self.scale (source, target, width, height = nil)
+            height = width unless height
+
+            # Scale source
+            simg = Magick::Image.read(source)[0]
+
+            if simg.columns > width && simg.rows > height
+                simg.resize_to_fit!(width, height)
+            end
+                        
+            # Create transparent image
+            timg = Magick::Image.new(width, height)
+            d = Magick::Draw.new
+            d.fill('white')
+            d.draw(timg)
+            timg = timg.transparent('white')
+
+            # Insert thumb
+            timg.composite!(simg, Magick::CenterGravity, Magick::OverCompositeOp)
+
+            # Save result
+            timg.write(target)
+        end
+
+    end
+    
+end

data/lib/command_wrap/open_office.rb

@@ -0,0 +1,40 @@
+module CommandWrap
+
+    module OpenOffice
+
+        autoload :Server,   File.dirname(__FILE__) + "/open_office/server"
+
+        # Converts the given source to target
+        #
+        # Possible parameters:
+        # source (path to source file) + target (path to target file)
+        # content (content of source file) + source extension (extension of source file) + target extension (extension of target file)
+        def self.convert (*args)
+            if args.length == 2
+                source = args[0]
+                target = args[1]
+            elsif args.length == 3
+                source = CommandWrap.temp(args[1])
+                target = CommandWrap.temp(args[2])
+                # Save Content
+                File.open(source, 'w') do |file|
+                    file.write args[0]
+                end
+            else
+                raise ArgumentError.new('wrong number of arguments')
+            end
+            command = File.dirname(__FILE__) + "/../../bin/DocumentConverter.py"
+            result = `#{CommandWrap::Config::OpenOffice.python} #{command}  #{source} #{target} #{CommandWrap::Config::OpenOffice.port}`
+            raise result unless result.strip == ''
+
+            if args.length == 3
+                result = IO.read(target)
+                File.delete(source) if File.writable?(source)
+                File.delete(target) if File.writable?(target)
+                result
+            end
+        end
+
+    end
+
+end

data/lib/command_wrap/open_office/server.rb

@@ -0,0 +1,29 @@
+module CommandWrap::OpenOffice
+
+    module Server
+
+        def self.start
+            pid1 = fork do
+                exec FileUtils::Config::OpenOffice.xvfb
+            end
+            sleep 5 # 5 seconden wachten tot xvfb draait
+            pid2 = fork do
+                exec FileUtils::Config::OpenOffice.command
+            end            
+        end
+
+        def self.stop
+            `#{FileUtils::Config::OpenOffice.stop_xvfb}`
+            sleep 5
+            `#{FileUtils::Config::OpenOffice.stop}`
+        end
+
+        def self.restart
+            stop
+            sleep 5
+            start
+        end
+
+    end
+
+end

data/lib/command_wrap/pdf.rb

@@ -0,0 +1,47 @@
+require 'RMagick'
+
+module CommandWrap
+
+    module Pdf
+
+        def self.metas (path)
+            metas = {}
+
+            key = ''
+            `#{CommandWrap::Config.pdftk} #{path} dump_data`.gsub("\r\n", "\n").gsub("\r", "\n").split("\n").each do |line|
+                parts = line.split(':')
+                parts[1] = parts[1].gsub('�', '')
+                if parts[0] == 'InfoValue'
+                    if key != ''
+                        metas[key] = parts[1].strip
+                        key = ''
+                    end
+                elsif parts[0] == 'InfoKey'
+                    key = parts[1].strip
+                else
+                    metas[parts[0].strip] = parts[1].strip
+                end
+            end            
+
+            metas
+        end
+
+        def self.pages (path)
+            metas(path)['NumberOfPages'].to_i
+        end
+
+        # Generates an image of a pdf page
+        # Page starts with 0
+        def self.preview (source, target, page = 0)
+            pdf = Magick::ImageList.new(source)[page]
+            pdf.write target
+        end
+
+        # Merges the given pdfs into a single pdf
+        def self.merge (target, *sources)
+            `#{CommandWrap::Config.pdftk} #{sources.join(' ')} cat output #{target}`
+        end
+        
+    end
+
+end

data/tests/helpers/test.htm

@@ -0,0 +1 @@
+TEST.HTM

data/tests/helpers/test.html

@@ -0,0 +1 @@
+TESTING

data/tests/helpers/test.txt

@@ -0,0 +1 @@
+test

data/tests/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require 'rubygems'
+require File.dirname(__FILE__) + "/../lib/command_wrap"

data/tests/unit/command_wrap_test.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class CommandWrapTest < Test::Unit::TestCase
+
+    def test_capture
+        assert_nothing_raised do
+            path = File.dirname(__FILE__) + "/../../google.png"
+            File.delete(path) if File.exists?(path)
+            CommandWrap.capture('http://www.google.be', path)
+            assert File.exists?(path)
+        end
+    end
+
+    def test_zip
+        target = File.dirname(__FILE__) + "/../../result.zip"
+        source1 = File.dirname(__FILE__) + "/../helpers/2pages.pdf"
+        source2 = File.dirname(__FILE__) + "/../helpers/test.odt"
+
+        File.delete(target) if File.exists?(target)
+
+        assert_nothing_raised do
+            CommandWrap.zip(target, source1, 'doc.pdf', source2, 'doc.odt')
+            assert File.exists?(target)
+        end
+    end
+
+    def test_extension
+        assert_equal 'exe', CommandWrap.extension('test.exe')
+    end
+
+    def test_extension_none
+        assert_equal '', CommandWrap.extension('test')
+    end
+
+    def test_preview
+        target = File.dirname(__FILE__) + "/../../result.png"
+
+        assert_nothing_raised do
+            source = File.dirname(__FILE__) + "/../../README"
+            
+            assert_nil CommandWrap.preview(source, target, 100, 100)
+
+            # Image
+            source = File.dirname(__FILE__) + "/../helpers/scale.jpg"
+
+            File.delete(target) if File.exists?(target)
+
+            assert CommandWrap.preview(source, target, 100, 100), 'Creation of image preview'
+            assert File.exists?(target), 'File exists? preview of image'
+
+            # Document
+            source = File.dirname(__FILE__) + "/../helpers/test.odt"
+
+            File.delete(target) if File.exists?(target)
+
+            assert CommandWrap.preview(source, target, 100, 100), 'Creation of odt preview'
+            assert File.exists?(target), 'File exists? preview of odt'
+        end
+    end
+
+    def test_temppath
+        assert_nothing_raised do
+            path1 = CommandWrap.temp('jpg')
+            assert_equal "#{CommandWrap::Config.tmp_dir}/tmp.jpg", path1
+
+            FileUtils.touch(path1)
+
+            path2 = CommandWrap.temp('jpg')
+            assert_equal "#{CommandWrap::Config.tmp_dir}/tmp.1.jpg", path2
+
+            File.delete(path1)
+        end
+    end
+
+    def test_index
+        assert_nothing_raised do
+            assert_equal '', CommandWrap.index(File.dirname(__FILE__) + "/../helpers/scale.jpg")
+            assert_equal 'test', CommandWrap.index(File.dirname(__FILE__) + "/../helpers/test.txt")
+            assert CommandWrap.index(File.dirname(__FILE__) + "/../helpers/test.odt").include?('TEST'), 'TEST in odt'
+            assert_equal 'TESTING', CommandWrap.index(File.dirname(__FILE__) + "/../helpers/test.html")
+            assert_equal 'TEST.HTM', CommandWrap.index(File.dirname(__FILE__) + "/../helpers/test.htm")
+        end
+    end
+
+    def test_preview_mpg
+        source = File.dirname(__FILE__) + "/../helpers/test.mpg"
+        target = CommandWrap.temp('png')
+        File.delete(target) if File.exists?(target)
+        assert_nothing_raised do
+            assert_equal false, CommandWrap.preview(source, target, 160, 200)
+        end
+    end
+
+end

data/tests/unit/config_open_office_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ConfigOpenOfficeTest < Test::Unit::TestCase
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::Config::OpenOffice
+        end
+    end
+
+    def setup
+        @params = {
+            :executable => CommandWrap::Config::OpenOffice.executable,
+            :host       => CommandWrap::Config::OpenOffice.host,
+            :port       => CommandWrap::Config::OpenOffice.port,
+            :params     => CommandWrap::Config::OpenOffice.params,
+            :xvfb       => CommandWrap::Config::OpenOffice.xvfb,
+            :stop_xvfb  => CommandWrap::Config::OpenOffice.stop_xvfb,
+            :stop       => CommandWrap::Config::OpenOffice.stop,
+            :python     => CommandWrap::Config::OpenOffice.python
+        }
+    end
+
+    # Reset of config
+    def teardown
+        CommandWrap::Config::OpenOffice.executable = @params[:executable] 
+        CommandWrap::Config::OpenOffice.host       = @params[:host]
+        CommandWrap::Config::OpenOffice.port       = @params[:port]
+        CommandWrap::Config::OpenOffice.params     = @params[:params]
+        CommandWrap::Config::OpenOffice.xvfb       = @params[:xvfb]
+        CommandWrap::Config::OpenOffice.stop_xvfb  = @params[:stop_xvfb]
+        CommandWrap::Config::OpenOffice.stop       = @params[:stop]
+        CommandWrap::Config::OpenOffice.python     = @params[:python]
+    end
+
+    def test_config_openoffice_executable
+        assert_kind_of String, CommandWrap::Config::OpenOffice.executable
+        assert_equal 'soffice', CommandWrap::Config::OpenOffice.executable
+        CommandWrap::Config::OpenOffice.executable = 'soffice.exe'
+        assert_equal 'soffice.exe', CommandWrap::Config::OpenOffice.executable
+        CommandWrap::Config::OpenOffice.executable = 'soffice'
+    end
+
+    def test_config_openoffice_port
+        assert_kind_of Integer, CommandWrap::Config::OpenOffice.port
+        assert_equal 8000, CommandWrap::Config::OpenOffice.port
+        CommandWrap::Config::OpenOffice.port = 8020
+        assert_equal 8020, CommandWrap::Config::OpenOffice.port
+        CommandWrap::Config::OpenOffice.port = 8000
+    end
+
+    def test_config_openoffice_host
+        assert_kind_of String, CommandWrap::Config::OpenOffice.host
+        assert_equal '127.0.0.1', CommandWrap::Config::OpenOffice.host
+        CommandWrap::Config::OpenOffice.host = 'localhost'
+        assert_equal 'localhost', CommandWrap::Config::OpenOffice.host
+        CommandWrap::Config::OpenOffice.host = '127.0.0.1'
+    end
+
+    def test_config_openoffice_params
+        assert_kind_of String, CommandWrap::Config::OpenOffice.params
+        assert_equal '-headless -display :30 -accept="socket,host=[host],port=[port];urp;" -nofirststartwizard', CommandWrap::Config::OpenOffice.params
+        CommandWrap::Config::OpenOffice.params = '-headless -accept="socket,host=127.0.0.1,port=8100;urp;" -nofirststartwizard'
+        assert_equal '-headless -accept="socket,host=127.0.0.1,port=8100;urp;" -nofirststartwizard', CommandWrap::Config::OpenOffice.params
+        CommandWrap::Config::OpenOffice.params = '-headless -accept="socket,host=[host],port=[port];urp;" -nofirststartwizard'
+    end
+
+    def test_config_openoffice_command
+        assert_kind_of String, CommandWrap::Config::OpenOffice.command
+        assert_equal 'soffice -headless -display :30 -accept="socket,host=127.0.0.1,port=8000;urp;" -nofirststartwizard', CommandWrap::Config::OpenOffice.command
+
+        CommandWrap::Config::OpenOffice.executable  = 'soffice.exe'
+        CommandWrap::Config::OpenOffice.host = 'localhost'
+        CommandWrap::Config::OpenOffice.port = 8080
+        CommandWrap::Config::OpenOffice.params = '-headless -display :30 -accept="socket,host=[host],port=[port];urp;"'
+
+        assert_equal 'soffice.exe -headless -display :30 -accept="socket,host=localhost,port=8080;urp;"', CommandWrap::Config::OpenOffice.command
+    end
+
+    def test_config_openoffice_xvfb
+        assert_kind_of String, CommandWrap::Config::OpenOffice.xvfb
+        assert_equal 'Xvfb :30 -screen 0 1024x768x24', CommandWrap::Config::OpenOffice.xvfb
+        CommandWrap::Config::OpenOffice.xvfb = 'Xvfb'
+        assert_equal 'Xvfb', CommandWrap::Config::OpenOffice.xvfb
+    end
+
+    def test_config_openoffice_stop_xvfb
+        assert_kind_of String, CommandWrap::Config::OpenOffice.stop_xvfb
+        assert_equal 'killall -9 Xvfb', CommandWrap::Config::OpenOffice.stop_xvfb
+        CommandWrap::Config::OpenOffice.stop_xvfb = 'echo "dummy"'
+        assert_equal 'echo "dummy"', CommandWrap::Config::OpenOffice.stop_xvfb
+    end
+
+    def test_config_openoffice_stop
+        assert_kind_of String, CommandWrap::Config::OpenOffice.stop
+        assert_equal 'killall -9 soffice.bin', CommandWrap::Config::OpenOffice.stop
+        CommandWrap::Config::OpenOffice.stop = 'echo "dummy"'
+        assert_equal 'echo "dummy"', CommandWrap::Config::OpenOffice.stop
+    end
+
+    def test_config_openoffice_python
+        assert_kind_of String, CommandWrap::Config::OpenOffice.python
+        assert_equal 'python', CommandWrap::Config::OpenOffice.python
+        CommandWrap::Config::OpenOffice.python = '/usr/bin/python'
+        assert_equal '/usr/bin/python', CommandWrap::Config::OpenOffice.python 
+    end
+
+end

data/tests/unit/config_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::Config
+        end
+    end
+
+    def test_tmp_dir
+        tmp_dir = '/tmp'
+        assert_equal tmp_dir, CommandWrap::Config.tmp_dir
+        CommandWrap::Config.tmp_dir = '/home/test/tmp'
+        assert_equal '/home/test/tmp', CommandWrap::Config.tmp_dir
+        CommandWrap::Config.tmp_dir = tmp_dir
+    end
+
+    def test_pdftk
+        pdftk = 'pdftk'
+        assert_equal pdftk, CommandWrap::Config.pdftk
+        assert_equal 'pdftk', CommandWrap::Config.pdftk
+        CommandWrap::Config.pdftk = '/usr/bin/pdftk'
+        assert_equal '/usr/bin/pdftk', CommandWrap::Config.pdftk
+        CommandWrap::Config.pdftk = pdftk
+    end
+
+    def test_zip
+        zip = 'zip'
+        assert_equal 'zip', CommandWrap::Config.zip
+        CommandWrap::Config.zip = '/usr/bin/zip'
+        assert_equal '/usr/bin/zip', CommandWrap::Config.zip
+        CommandWrap::Config.zip = zip
+    end
+
+end

data/tests/unit/config_xvfb_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ConfigXvfbTest < Test::Unit::TestCase
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::Config::Xvfb
+        end
+    end
+
+    def teardown
+        CommandWrap::Config::Xvfb.executable = 'xvfb-run'
+        CommandWrap::Config::Xvfb.params = '--server-args="-screen 0, 1024x768x24"'
+    end
+
+    def test_config_xvbf_executable
+        assert_kind_of String, CommandWrap::Config::Xvfb.executable
+        assert_equal 'xvfb-run', CommandWrap::Config::Xvfb.executable
+        CommandWrap::Config::Xvfb.executable = '/usr/bin/xvfb-run'
+        assert_equal '/usr/bin/xvfb-run', CommandWrap::Config::Xvfb.executable
+    end
+
+    def test_params
+        assert_kind_of String, CommandWrap::Config::Xvfb.params
+        assert_equal '--server-args="-screen 0, 1024x768x24"', CommandWrap::Config::Xvfb.params
+        CommandWrap::Config::Xvfb.params = 'dummy'
+        assert_equal 'dummy', CommandWrap::Config::Xvfb.params
+    end
+
+    def test_command
+        assert_equal 'xvfb-run --server-args="-screen 0, 1024x768x24" echo "test"', CommandWrap::Config::Xvfb.command('echo "test"')
+    end
+        
+end

data/tests/unit/image_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ImageTest < Test::Unit::TestCase
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::Image
+        end
+    end
+
+    def test_dimensions
+        dim =  { :width => 150, :height => 200 }
+                
+        assert_equal dim, CommandWrap::Image.dimensions(File.dirname(__FILE__) + "/../helpers/img150x200.jpg")
+    end
+
+    def test_scale
+        dim = { :width => 100, :height => 100 }
+        source = File.dirname(__FILE__) + "/../helpers/scale.jpg"
+        target = File.dirname(__FILE__) + "/../../target.png"
+
+        File.delete(target) if File.exists?(target)
+
+        CommandWrap::Image.scale(source, target, 100)
+        assert File.exists?(target)
+        assert_equal dim, CommandWrap::Image.dimensions(target)
+    end
+
+    def test_scale_width_and_height
+        dim = { :width => 100, :height => 150 }
+        source = File.dirname(__FILE__) + "/../helpers/scale.jpg"
+        target = File.dirname(__FILE__) + "/../../target2.png"
+
+        File.delete(target) if File.exists?(target)
+
+        CommandWrap::Image.scale(source, target, 100, 150)
+        assert File.exists?(target)
+        assert_equal dim, CommandWrap::Image.dimensions(target)
+    end
+
+    def test_scale_width_and_height_big
+        dim = { :width => 1000, :height => 1500 }
+        source = File.dirname(__FILE__) + "/../helpers/scale.jpg"
+        target = File.dirname(__FILE__) + "/../../target3.png"
+
+        File.delete(target) if File.exists?(target)
+
+        CommandWrap::Image.scale(source, target, 1000, 1500)
+        assert File.exists?(target)
+        assert_equal dim, CommandWrap::Image.dimensions(target)
+    end
+    
+end

data/tests/unit/open_office_server_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class OpenOfficeServerTest < Test::Unit::TestCase
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::OpenOffice::Server
+        end
+    end
+
+end

data/tests/unit/open_office_test.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class OpenOfficeTest < Test::Unit::TestCase
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::OpenOffice
+        end
+    end
+
+    def test_convert
+        assert_nothing_raised do
+            path = CommandWrap.temp('pdf')
+            CommandWrap::OpenOffice.convert File.dirname(__FILE__) + "/../helpers/test.odt", path
+            assert File.exists?(path), 'Pdf bestaat niet'
+            File.delete(path) if File.writable?(path)
+        end
+    end
+
+    def test_convert_stream
+        assert_nothing_raised do
+            content = IO.read(File.dirname(__FILE__) + "/../helpers/test.odt")
+            assert_kind_of String, CommandWrap::OpenOffice.convert(content, 'odt', 'pdf') 
+        end
+    end
+
+end

data/tests/unit/pdf_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class PdfTest < Test::Unit::TestCase
+
+    TEST_PDF = File.dirname(__FILE__) + "/../helpers/2pages.pdf"
+
+    def test_exists
+        assert_nothing_raised do
+            CommandWrap::Pdf
+        end
+    end
+
+    def test_metas
+        assert_nothing_raised do
+            metas = CommandWrap::Pdf.metas(TEST_PDF)
+            assert_kind_of Hash, metas
+            assert_equal 'OpenOffice.org 3.2', metas['Producer']
+        end
+    end
+
+    def test_pages
+        assert_equal 2, CommandWrap::Pdf.pages(TEST_PDF)
+    end
+
+    def test_screenshot
+        target1 = File.dirname(__FILE__) + "/../../pdf1.jpg"
+        target2 = File.dirname(__FILE__) + "/../../pdf2.jpg"
+        target3 = File.dirname(__FILE__) + "/../../pdf3.jpg"
+
+        [target1, target2, target2].each do |target|
+            File.delete(target) if File.exists?(target)
+        end
+                
+        assert_nothing_raised do
+            CommandWrap::Pdf.preview(TEST_PDF, target1)
+            assert File.exists?(target1)
+            CommandWrap::Pdf.preview(TEST_PDF, target2, 0)
+            assert File.exists?(target2)
+            CommandWrap::Pdf.preview(TEST_PDF, target3, 1)
+            assert File.exists?(target3)
+            assert_equal IO.read(target1), IO.read(target2)
+        end
+    end
+
+    def test_merge
+        source1 = File.dirname(__FILE__) + "/../helpers/2pages.pdf"
+        source2 = File.dirname(__FILE__) + "/../helpers/pdf2.pdf"
+        target  = File.dirname(__FILE__) + "/../../result.pdf"
+
+        File.delete(target) if File.exists?(target)
+
+        assert_nothing_raised do
+            CommandWrap::Pdf.merge(target, source1, source2)
+            assert File.exists?(target)
+            assert_equal 3, CommandWrap::Pdf.pages(target)
+        end
+    end
+
+    def test_merge_3
+        source1 = File.dirname(__FILE__) + "/../helpers/2pages.pdf"
+        source2 = File.dirname(__FILE__) + "/../helpers/pdf2.pdf"
+        source3 = File.dirname(__FILE__) + "/../helpers/pdf3.pdf"
+        target  = File.dirname(__FILE__) + "/../../result.pdf"
+
+        File.delete(target) if File.exists?(target)
+
+        assert_nothing_raised do
+            CommandWrap::Pdf.merge(target, source1, source2, source3)
+            assert File.exists?(target)
+            assert_equal 4, CommandWrap::Pdf.pages(target)
+        end
+    end
+
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: CommandWrap
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Stefaan Colman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-22 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 2
+        - 13
+        - 1
+        version: 2.13.1
+  type: :runtime
+  version_requirements: *id001
+description: A set of utility classes to extract meta data from different file types
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/command_wrap/config.rb
+- lib/command_wrap/open_office.rb
+- lib/command_wrap/config/open_office.rb
+- lib/command_wrap/config/xvfb.rb
+- lib/command_wrap/open_office/server.rb
+- lib/command_wrap/image.rb
+- lib/command_wrap/pdf.rb
+- lib/command_wrap.rb
+- tests/unit/command_wrap_test.rb
+- tests/unit/pdf_test.rb
+- tests/unit/config_test.rb
+- tests/unit/open_office_test.rb
+- tests/unit/config_xvfb_test.rb
+- tests/unit/image_test.rb
+- tests/unit/config_open_office_test.rb
+- tests/unit/open_office_server_test.rb
+- tests/helpers/test.odt
+- tests/helpers/2pages.pdf
+- tests/helpers/scale.jpg
+- tests/helpers/pdf3.pdf
+- tests/helpers/test.htm
+- tests/helpers/test.html
+- tests/helpers/test.txt
+- tests/helpers/img150x200.jpg
+- tests/helpers/error.mpg
+- tests/helpers/pdf2.pdf
+- tests/test_helper.rb
+- README
+- bin/CutyCapt
+- bin/openoffice_server.rb
+- bin/DocumentConverter.py
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Extracting meta data from file
+test_files: 
+- tests/unit/command_wrap_test.rb
+- tests/unit/pdf_test.rb
+- tests/unit/config_test.rb
+- tests/unit/open_office_test.rb
+- tests/unit/config_xvfb_test.rb
+- tests/unit/image_test.rb
+- tests/unit/config_open_office_test.rb
+- tests/unit/open_office_server_test.rb
+- tests/test_helper.rb