poleica 0.9.6

data/lib/poleica/converters/libre_office.rb

@@ -0,0 +1,103 @@
+# -*- encoding: utf-8 -*-
+require 'fileutils'
+
+module Poleica
+  module Converters
+    # The LibreOffice converter, use the 'soffice' command to convert documents
+    class LibreOffice
+      include Poleica::Converters::Utils
+
+      BIN_PATHS = {
+        linux:  '/usr/bin/soffice',
+        osx: '/Applications/LibreOffice.app/Contents/MacOS/soffice'
+      }
+
+      COMPATIBLE_TYPES = [
+        Types::Document
+      ]
+
+      attr_reader :polei
+
+      def initialize(polei)
+        @polei = polei
+      end
+
+      def to_pdf(options = {})
+        opts_gen = OptionsGenerator.new(polei, options, :pdf)
+        cmd      = "#{bin_path} #{opts_gen.generate}"
+        `#{cmd}`
+        expected_file_path = opts_gen[:path] || polei.path_with_md5(:pdf)
+        File.exists?(expected_file_path) ? expected_file_path : nil
+      ensure
+        temp_file_path = opts_gen.temp_path
+        File.delete(temp_file_path) if File.exists?(temp_file_path)
+      end
+
+      private
+
+      # Generate options for the soffice command
+      class OptionsGenerator
+        attr_reader :options, :format, :polei
+
+        def initialize(polei, options = {}, format = :pdf)
+          defaults = {}
+          @options = defaults.merge(options)
+          @polei   = polei
+          @format  = format
+        end
+
+        def generate
+          "#{default_options} #{format} #{output_options}"
+        end
+
+        def [](key)
+          options[key]
+        end
+
+        # Generate a temp path, and create the file this is needed in order to
+        # have the right filename, LibreOffice just copy the original filename
+        # in the choosen directory, it doesn't accept filename params.
+        # @return temp_path [String]
+        def temp_path
+          @temp_path ||= generate_temp_path
+          FileUtils.cp(polei.path, @temp_path) unless File.exists?(@temp_path)
+          @temp_path
+        end
+
+        private
+
+        def generate_temp_path
+          if options[:path]
+            if File.directory?(options[:path])
+              basename = File.basename(polei.path_with_md5)
+              return File.join(options[:path], basename)
+            end
+            extension = File.extname(polei.path)
+            return pathable_object.path_for_extension(extension[1..-1])
+          else
+            return polei.path_with_md5(polei.file_extension)
+          end
+        end
+
+        def pathable_object
+            pathable_object = Struct.new(:path).new(options[:path])
+            pathable_object.extend(Poleica::Pathable)
+        end
+
+        def default_options
+          '--headless --invisible --norestore --nolockcheck --convert-to'
+        end
+
+        def output_options
+          dir_path = File.dirname(temp_path)
+          "--outdir #{Utils.escape(dir_path)} #{Utils.escape(temp_path)}"
+        end
+
+        def pages_options
+          @pages_options ||= Array(options[:page]).
+            flatten.compact.uniq.sort.to_s
+        end
+      end # class OptionsGenerator
+    end # class LibreOffice
+  end # module Converters
+end # module Poleica

data/lib/poleica/converters/null.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  module Converters
+    # Null Object Pattern, this is the converter returned if no compatible
+    # converters are found
+    class Null
+      attr_reader :polei
+      def initialize(polei)
+        @polei = polei
+      end
+
+      def method_missing(method, *args, &block)
+        super unless method =~ /^to_/
+      end
+    end # class Null
+  end # module Converters
+end # module Poleica

data/lib/poleica/converters/utils.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+require 'digest/md5'
+require 'shellwords'
+
+module Poleica
+  module Converters
+    # An Utility module for the converters needs to be include
+    module Utils
+      HOST_OS ||= (defined?('RbConfig') ? RbConfig : Config)::CONFIG['host_os']
+
+      def windows?
+        !!HOST_OS.match(/mswin|windows|cygwin/i)
+      end
+
+      def osx?
+        !!HOST_OS.match(/darwin/i)
+      end
+
+      def linux?
+        !!HOST_OS.match(/linux/i)
+      end
+
+      def host_os
+        [:windows, :osx, :linux].find { |os| self.send(:"#{os}?") }
+      end
+
+      def bin_path
+        bin_path_key = :BIN_PATHS # rubocop:disable SymbolName
+        bin_paths    = self.class.const_get(bin_path_key)
+        path         = bin_paths[host_os] || bin_paths[:linux]
+        raise "#{self.class} not found @ #{path}" unless File.exists?(path)
+        path
+      end
+
+      module_function
+
+      def extract_extension_and_options(method, args = [])
+        extension  = method.to_s.split(/^to_(.*)/)[1]
+        options    = args.last if args.last.is_a?(Hash)
+        options    ||= {}
+        [extension, options]
+      end
+
+      def escape(string)
+        Shellwords.shellescape(string)
+      end
+    end
+  end
+end

data/lib/poleica/pathable.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  # Path methods
+  module Pathable
+    def path_for_extension(extension)
+      "#{path_without_extension}.#{extension}"
+    end
+
+    def path_without_extension
+      File.join(File.dirname(self.path), File.basename(self.path, '.*'))
+    end
+
+    def path_with_md5(extension = self.extension)
+      data   = File.read(self.path)
+      md5    = Digest::MD5.new
+      digest = md5.hexdigest(data)
+      "#{path_without_extension}-#{digest}.#{extension}"
+    end
+  end # class Pathable
+end # module Poleica

data/lib/poleica/polei.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  # Strange name for a simple object, it represents a File
+  class Polei
+    include Poleica::Typeable
+    include Poleica::Pathable
+    include Poleica::Convertible
+
+    attr_reader :path, :name
+
+    def initialize(path)
+      @path = path.strip
+      raise "No file @ #{path}" unless File.exists?(path)
+    end
+
+    def name
+      File.basename(path, ".#{extension}")
+    end
+
+    def extension
+      File.extname(path)[1..-1]
+    end
+  end # class Polei
+end # module Poleica

data/lib/poleica/types/archive.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  module Types
+    # Archive Type
+    class Archive
+      COMPATIBLE_MIMETYPES = [
+        'application/zip' # .zip or a range of docs like .key, .pptx or .docx
+      ]
+
+    end # class Archive
+  end # module Types
+end # module Poleica

data/lib/poleica/types/document.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  module Types
+    # Document Type
+    class Document
+      COMPATIBLE_MIMETYPES = [
+        'applicationiapplication/vnd.oasis.opendocument.image', # .odi
+        'application/vnd.oasis.opendocument.presentation',      # .opd
+        'application/vnd.oasis.opendocument.text-master',       # .odm
+        'application/vnd.oasis.opendocument.spreadsheet',       # .ods
+        'application/vnd.oasis.opendocument.graphics',          # .odg
+        'application/vnd.oasis.opendocument.formula',           # .odf
+        'application/vnd.oasis.opendocument.chart',             # .odc
+        'application/vnd.oasis.opendocument.text',              # .odt
+        'application/vnd.ms-office',                            # .doc
+        'application/vnd.ms-excel',                             # .xls
+        'application/vnd.ms-office',                            # .ppt, .pps
+        'application/msword',                                   # .doc
+        'text/html',                                            # .html, .htm
+        'text/plain',                                           # .txt
+        'text/rtf'                                              # .rft
+      ]
+
+      # Unsupported :( : key, pages
+      COMPATIBLE_EXTENSIONS = %w{
+        html
+        htm
+        odt
+        doc
+        ods
+        odp
+        odg
+        odc
+        odf
+        odb
+        odc
+        odm
+        docx
+        xls
+        xlsx
+        ppt
+        pptx
+        pps
+        txt
+        rft
+      }
+
+      def initialize(file_path)
+
+      end
+    end # class Document
+  end # module Types
+end # module Poleica

data/lib/poleica/types/image.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  module Types
+    # Image Type
+    class Image
+      COMPATIBLE_MIMETYPES = [
+        'image/x-portable-pixmap', # .ppm, .pgm, .pbm, .pnm
+        'image/x-portable-bitmap', # .pbm
+        'image/x-ms-bmp',          # .bmp
+        'image/svg+xml',           # .svg
+        'image/jpeg',              # .jpeg, .jpg
+        'image/tiff',              # .tiff, .tif
+        'image/gif',               # .gif
+        'image/png'                # .png
+      ]
+
+      COMPATIBLE_EXTENSIONS = %w{
+        tiff
+        jpeg
+        ppm
+        pgm
+        pnm
+        pbm
+        bmp
+        svg
+        jpg
+        tif
+        gif
+        png
+      }
+
+      def initialize(file_path)
+
+      end
+    end # class Image
+  end # module Types
+end # module Poleica

data/lib/poleica/types/null.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  module Types
+    # Null Object Pattern Type, this is the type returned if no compatible
+    # types are found
+    class Null
+      def initialize(file_path)
+
+      end
+    end # class Null
+  end # module Types
+end # module Poleica

data/lib/poleica/types/pdf.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  module Types
+    # PDF Type
+    class PDF
+      COMPATIBLE_MIMETYPES = [
+        'application/pdf' # pdf
+      ]
+
+      COMPATIBLE_EXTENSIONS = %w{
+        pdf
+      }
+
+      def initialize(file_path)
+
+      end
+    end # class PDF
+  end # module Types
+end # module Poleica

data/lib/poleica/types/typeable.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  # Retrieve the mimetype, the extension and the type of a file, it needs a
+  # "path" method
+  module Typeable
+    def file_extension
+      @file_extension ||= extract_extension
+    end
+
+    def file_mimetype
+      @file_mimetype ||= extract_mimetype
+    end
+
+    def file_type
+      @file_type ||= (detect_type_with_extension ||
+                      detect_type_with_mimetype  ||
+                      Types::Null).new(path)
+    end
+
+    private
+
+    MIMETYPE_EXTRACT_REGEX = /([^;:]+)/
+
+    TYPES = [
+      Types::Image,
+      Types::Document,
+      Types::PDF
+    ]
+
+    def extract_mimetype
+      `file -b --mime '#{path}'`.strip[MIMETYPE_EXTRACT_REGEX] || ''
+    end
+
+    def extract_extension
+      (::File.extname(path)[1..-1] || '').strip
+    end
+
+    def detect_type_with_extension
+      TYPES.find do |type|
+        type::COMPATIBLE_EXTENSIONS.include?(file_extension)
+      end
+    end
+
+    def detect_type_with_mimetype
+      TYPES.find do |type|
+        type::COMPATIBLE_MIMETYPES.include?(file_mimetype)
+      end
+    end
+  end # class Typeable
+end # module Poleica

data/lib/poleica/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  VERSION ||= '0.9.6'
+end # module Poleica

data/lib/poleica.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+module Poleica
+  def self.new(file_or_path)
+    file_or_path = file_or_path.path if file_or_path.respond_to?(:path)
+    Polei.new(file_or_path)
+  end
+end # module Poleica
+
+require 'poleica/version'
+
+require 'poleica/types/pdf'
+require 'poleica/types/null'
+require 'poleica/types/image'
+require 'poleica/types/document'
+require 'poleica/types/typeable'
+
+require 'poleica/converters/utils'
+require 'poleica/converters/general'
+require 'poleica/converters/null'
+require 'poleica/converters/coercive'
+require 'poleica/converters/graphics_magick'
+require 'poleica/converters/libre_office'
+require 'poleica/converters/convertible'
+
+require 'poleica/pathable'
+
+require 'poleica/polei'

data/poleica.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/poleica/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'poleica'
+  s.version       = Poleica::VERSION
+  s.license       = 'MIT'
+  s.summary       = 'A general converter and thumbnail creator'
+  s.description   = 'Poleica can convert docs and images to PDF and PNG, it can be extended to handle a lot of converters'
+  s.authors       = ['Antoine Lyset']
+  s.email         = 'antoinelyset@gmail.com'
+  s.homepage      = 'https://github.com/antoinelyset/poleica'
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_development_dependency 'bundler', '~> 1.3'
+  s.add_development_dependency 'rake'
+end

data/test/poleica/converters/coercive_test.rb

@@ -0,0 +1,77 @@
+# -*- encoding: utf-8 -*-
+require 'test_helper'
+# Test the Coercive Converter Module
+
+class CoerciveTest < Minitest::Test
+  DOC_PATH = "#{Support.support_path}/files/example.doc"
+
+  def test_find_next_converter_by_method
+    conv_hash = coercive_conv.send(:find_next_converter_by_method, :to_png)
+    assert_equal({ to_pdf: Poleica::Converters::GraphicsMagick }, conv_hash)
+  end
+
+  def test_next_converters_by_method
+    next_convs     = coercive_conv.send(:next_converters_by_method)
+    expected_convs = [{ to_pdf: Poleica::Converters::GraphicsMagick }]
+    assert_equal(expected_convs, next_convs)
+  end
+
+  def test_try_convert_intermediary_file_creation
+    coercive_conv.send(:coerce, :to_png, {})
+    assert(File.exists?(expected_pdf_path))
+    clean_png_file
+    clean_pdf_file
+  end
+
+  def test_try_convert_file_creation
+    coercive_conv.send(:try_convert, :to_png)
+    assert(File.exists?(find_png_path))
+    clean_png_file(find_png_path)
+    clean_pdf_file
+  end
+
+  def test_coercive_conversion
+    polei = Poleica.new(DOC_PATH)
+    returned_path = polei.to_png
+    assert(File.exists?(returned_path))
+    clean_png_file(find_png_path)
+  end
+
+  def test_coercive_null_return
+    polei = Poleica.new("#{Support.support_path}/files/example.mp3")
+    returned_path = polei.to_png
+    assert_equal(nil, returned_path)
+  end
+
+  private
+
+  def clean_pdf_file
+    File.exists?(expected_pdf_path) && File.delete(expected_pdf_path)
+  end
+
+  def clean_png_file(png_path = expected_png_path)
+    File.exists?(png_path) && File.delete(png_path)
+  end
+
+  def expected_pdf_path
+    Support.expected_converted_path(DOC_PATH, :pdf)
+  end
+
+  def expected_png_path
+    Support.expected_converted_path(expected_pdf_path, :png)
+  end
+
+  # Find a the path of the converted png. It should be used when we
+  # don't have the intermediate file since we need to calculate its
+  # md5
+  def find_png_path
+    files = Dir["#{Support.support_path}/files/*"]
+    start_path = Support.path_without_extension(expected_pdf_path)
+    files.grep(/#{start_path}-\w+\.png$/).first
+  end
+
+  def coercive_conv
+    doc_polei = Poleica::Polei.new("#{DOC_PATH}")
+    Poleica::Converters::Coercive.new(doc_polei)
+  end
+end # class CoerciveTest

data/test/poleica/converters/convertible_test.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+require 'test_helper'
+# Test the Convertible Module
+class ConvertibleTest < Minitest::Test
+  def test_that_it_extracts_converters
+    mp3_path  = "#{Support.support_path}/files/example.mp3"
+    mp3_polei = Poleica::Polei.new(mp3_path)
+    # FIXME
+    expected_converters = [Poleica::Converters::General]
+    assert_equal(expected_converters, mp3_polei.send(:compatible_converters))
+  end
+
+  def test_that_it_extracts_converters_2
+    png_path  = "#{Support.support_path}/files/example.png"
+    png_polei = Poleica::Polei.new(png_path)
+    expected_converters = [
+      Poleica::Converters::GraphicsMagick,
+      Poleica::Converters::General
+    ]
+    # FIXME
+    assert_equal(expected_converters, png_polei.send(:compatible_converters))
+  end
+
+  def test_convert_to_extension
+    png_path  = "#{Support.support_path}/files/example.png"
+    png_polei = Poleica::Polei.new(png_path)
+    converter = png_polei.send(:converter_to_extension, :png)
+    assert_equal(Poleica::Converters::GraphicsMagick, converter)
+  end
+
+  def test_default_coercive_converter
+    png_path  = "#{Support.support_path}/files/example.png"
+    png_polei = Poleica::Polei.new(png_path)
+    converter = png_polei.send(:converter_to_extension, :mp3)
+    assert_equal(Poleica::Converters::Coercive, converter)
+  end
+
+  def test_method_missing_raises_exception
+    method_name = :random
+    png_path    = "#{Support.support_path}/files/example.png"
+    png_polei   = Poleica::Polei.new(png_path)
+    assert_raises(NoMethodError) { png_polei.send(method_name) }
+  end
+end # class ConvertibleTest

data/test/poleica/converters/general_test.rb

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+require 'test_helper'
+# Test the General Converter Module
+class GeneralTest < Minitest::Test
+  def test_to_bin
+    gif_path = "#{Support.support_path}/files/1px.gif"
+    gif_data = File.binread(gif_path)
+    gif_polei = Poleica::Polei.new(gif_path)
+    assert_equal(gif_data, gif_polei.to_bin)
+  end
+end # class GeneralTest