mindee 4.12.0 → 5.0.0.beta1

data/lib/mindee/pdf/pdf_extractor.rb

@@ -3,118 +3,119 @@
 module Mindee
   # Pdf Extraction Module.
   module PDF
-    # Pdf Extraction class.
-    module PDFExtractor
-      # Pdf extraction class.
-      class PDFExtractor
-        # @param local_input [Mindee::Input::Source::LocalInputSource]
-        def initialize(local_input)
-          @filename = local_input.filename
-          if local_input.pdf?
-            @source_pdf = local_input.io_stream
-          else
-            pdf_image = Image::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
-            io_buffer = StringIO.new
-            pdf_image.save(io_buffer)
-
-            @source_pdf = io_buffer
-          end
+    # Pdf extraction class.
+    class PDFExtractor
+      # @param local_input [Mindee::Input::Source::LocalInputSource]
+      def initialize(local_input)
+        unless Mindee::Dependency.all_deps_available?
+          raise NotImplementedError, Mindee::Dependency::MINDEE_DEPENDENCIES_LOAD_ERROR
         end
 
-        # Retrieves the page count for the Pdf object.
-        # @return [Integer]
-        def page_count
-          Mindee::PDF::PDFProcessor.open_pdf(@source_pdf).pages.size
+        @filename = local_input.filename
+        if local_input.pdf?
+          @source_pdf = local_input.io_stream
+        else
+          pdf_image = Image::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
+          io_buffer = StringIO.new
+          pdf_image.save(io_buffer)
+
+          @source_pdf = io_buffer
         end
+      end
 
-        # Creates a new Pdf from pages and save it into a buffer.
-        # @param page_indexes [Array<Integer>] List of page number to use for merging in the original Pdf.
-        # @return [StringIO] The buffer containing the new Pdf.
-        def cut_pages(page_indexes)
-          options = PageOptions.new(params: {
-                                      page_indexes: page_indexes,
-                                    })
+      # Retrieves the page count for the Pdf object.
+      # @return [Integer]
+      def page_count
+        Mindee::PDF::PDFProcessor.open_pdf(@source_pdf).pages.size
+      end
 
-          Mindee::PDF::PDFProcessor.parse(@source_pdf, options)
-        end
+      # Creates a new Pdf from pages and save it into a buffer.
+      # @param page_indexes [Array<Integer>] List of page number to use for merging in the original Pdf.
+      # @return [StringIO] The buffer containing the new Pdf.
+      def cut_pages(page_indexes)
+        options = PageOptions.new(params: {
+                                    page_indexes: page_indexes,
+                                  })
 
-        # Extract the sub-documents from the main pdf, based on the given list of page indexes.
-        # @param page_indexes [Array<Array<Integer>>] List of page number to use for merging in the original Pdf.
-        # @return [Array<Mindee::PDF::PDFExtractor::ExtractedPDF>] The buffer containing the new Pdf.
-        def extract_sub_documents(page_indexes)
-          extracted_pdfs = []
-          extension = File.extname(@filename)
-          basename = File.basename(@filename, extension)
-          page_indexes.each do |page_index_list|
-            if page_index_list.nil? || page_index_list.empty?
-              raise Errors::MindeePDFError, "Empty indexes aren't allowed for extraction #{page_index_list}"
-            end
+        Mindee::PDF::PDFProcessor.parse(@source_pdf, options)
+      end
+
+      # Extract the sub-documents from the main pdf, based on the given list of page indexes.
+      # @param page_indexes [Array<Array<Integer>>] List of page number to use for merging in the original Pdf.
+      # @return [Array<Mindee::PDF::ExtractedPDF>] The buffer containing the new Pdf.
+      def extract_sub_documents(page_indexes)
+        extracted_pdfs = [] # @type var extracted_pdfs: Array[Mindee::PDF::ExtractedPDF]
+        extension = File.extname(@filename)
+        basename = File.basename(@filename, extension)
+        page_indexes.each do |page_index_list|
+          if page_index_list.nil? || page_index_list.empty?
+            raise Error::MindeePDFError, "Empty indexes aren't allowed for extraction #{page_index_list}"
+          end
 
-            page_index_list.each do |page_index|
-              if (page_index > page_count) || page_index.negative?
-                raise Errors::MindeePDFError,
-                      "Index #{page_index} is out of range."
-              end
+          page_index_list.each do |page_index|
+            if (page_index > page_count) || page_index.negative?
+              raise Error::MindeePDFError,
+                    "Index #{page_index} is out of range."
             end
-            formatted_max_index = format('%03d', page_index_list[page_index_list.length - 1] + 1).to_s
-            field_filename = "#{basename}_#{format('%03d',
-                                                   page_index_list[0] + 1)}-#{formatted_max_index}#{extension}"
-            extracted_pdf = Mindee::PDF::PDFExtractor::ExtractedPDF.new(cut_pages(page_index_list),
-                                                                        field_filename)
-            extracted_pdfs << extracted_pdf
           end
-          extracted_pdfs
+          formatted_max_index = format('%03d', page_index_list[-1] + 1).to_s
+          field_filename = "#{basename}_#{format('%03d',
+                                                 page_index_list[0] + 1)}-#{formatted_max_index}#{extension}"
+          extracted_pdf = Mindee::PDF::ExtractedPDF.new(cut_pages(page_index_list),
+                                                        field_filename)
+          extracted_pdfs << extracted_pdf
         end
+        extracted_pdfs
+      end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
 
-        # Extracts invoices as complete PDFs from the document.
-        # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1InvoicePageGroup>]
-        # @param strict [bool]
-        # @return [Array<Mindee::PDF::PDFExtractor::ExtractedPDF>]
-        def extract_invoices(page_indexes, strict: false)
-          raise Errors::MindeePDFError, 'No indexes provided.' if page_indexes.empty?
+      # Extracts invoices as complete PDFs from the document.
+      # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1InvoicePageGroup>]
+      # @param strict [bool]
+      # @return [Array<Mindee::PDF::ExtractedPDF>]
+      def extract_invoices(page_indexes, strict: false)
+        raise Error::MindeePDFError, 'No indexes provided.' if page_indexes.empty?
 
-          if page_indexes[0].is_a?(Array) && page_indexes[0].all? { |i| i.is_a?(Integer) }
-            page_indexes_as_array = page_indexes # @type var page_indexes : Array[Array[Integer]]
-            return extract_sub_documents(page_indexes_as_array)
-          end
-          p_ids = page_indexes # @type var page_indexes: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroups
-          return extract_sub_documents(p_ids.map(&:page_indexes)) unless strict
-
-          correct_page_indexes = []
-          current_list = []
-          previous_confidence = nil
-          p_ids.each_with_index do |p_i, i|
-            page_index = p_i # @type var page_index: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroup
-            confidence = page_index.confidence.to_f
-            page_list = page_index.page_indexes
-
-            if confidence >= 0.5 && previous_confidence.nil?
-              current_list = page_list
-            elsif confidence >= 0.5 && i < p_ids.length - 1
-              correct_page_indexes << current_list
-              current_list = page_list
-            elsif confidence < 0.5 && i == p_ids.length - 1
-              current_list.concat page_list
-              correct_page_indexes << current_list
-            else
-              correct_page_indexes << current_list
-              correct_page_indexes << page_list
-            end
-            previous_confidence = confidence
+        if page_indexes[0].is_a?(Array) && page_indexes[0].all?(Integer)
+          page_indexes_as_array = page_indexes # @type var page_indexes : Array[Array[Integer]]
+          return extract_sub_documents(page_indexes_as_array)
+        end
+        p_ids = page_indexes # @type var page_indexes: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroups
+        return extract_sub_documents(p_ids.map(&:page_indexes)) unless strict
+
+        correct_page_indexes = [] # @type var correct_page_indexes: Array[Array[Integer]]
+        current_list = [] # @type var current_list: Array[Integer]
+        previous_confidence = nil
+        p_ids.each_with_index do |p_i, i|
+          page_index = p_i # @type var page_index: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroup
+          confidence = page_index.confidence.to_f
+          page_list = page_index.page_indexes
+
+          if confidence >= 0.5 && previous_confidence.nil?
+            current_list = page_list
+          elsif confidence >= 0.5 && i < p_ids.length - 1
+            correct_page_indexes << current_list
+            current_list = page_list
+          elsif confidence < 0.5 && i == p_ids.length - 1
+            current_list.concat page_list
+            correct_page_indexes << current_list
+          else
+            correct_page_indexes << current_list
+            correct_page_indexes << page_list
           end
-          extract_sub_documents(correct_page_indexes)
+          previous_confidence = confidence
         end
+        extract_sub_documents(correct_page_indexes)
+      end
 
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
-        private
+      private
 
-        attr_reader :source_pdf, :filename
-      end
+      attr_reader :source_pdf, :filename
     end
   end
 end

data/lib/mindee/pdf/pdf_processor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
+Mindee::Dependency.require_all_deps!
 require 'origami'
 require_relative 'pdf_tools'
 
@@ -61,6 +61,11 @@ module Mindee
       # @param io_stream [StringIO]
       # @return [Origami::PDF]
       def self.open_pdf(io_stream)
+        unless PDFTools.pdf_header?(io_stream)
+          raise Origami::InvalidPDFError,
+                'Input stream does not contain a PDF header.'
+        end
+
         pdf_parser = Origami::PDF::LinearParser.new({ verbosity: Origami::Parser::VERBOSE_QUIET })
         io_stream.seek(0)
         pdf_parser.parse(io_stream)

data/lib/mindee/pdf/pdf_tools.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+Mindee::Dependency.require_all_deps!
 require 'origami'
 
 module Mindee
@@ -53,10 +54,28 @@ module Mindee
         text_operators.any? { |op| data.include?(op) }
       end
 
+      # Checks whether a stream contains a PDF header near the beginning.
+      # @param [StringIO] io_stream Binary-encoded stream.
+      # @param [Integer] maximum_offset Maximum allowed offset to find '%PDF-'.
+      # @return [bool] `true` when the stream appears to be a PDF.
+      def self.pdf_header?(io_stream, maximum_offset: 500)
+        initial_pos = nil
+        initial_pos = io_stream.pos if io_stream.respond_to?(:pos)
+        io_stream.seek(0)
+        io_stream.gets('%PDF-')
+        !(io_stream.eof? || io_stream.pos > maximum_offset)
+      rescue TypeError, IOError, SystemCallError
+        false
+      ensure
+        io_stream.seek(initial_pos) if !initial_pos.nil? && io_stream.respond_to?(:seek)
+      end
+
       # Checks whether the file has source_text. Sends false if the file isn't a PDF.
       # @param [StringIO] pdf_data Abinary-encoded stream representing the PDF file.
       # @return [bool] `true` if the pdf has source text, false otherwise.
       def self.source_text?(pdf_data)
+        return false unless pdf_header?(pdf_data)
+
         begin
           pdf_data.rewind
           pdf = Origami::PDF.read(pdf_data)