FileTextExtractor::for_file() - Code Metrics - Inspection of "Merge pull request #46 from creative-commoners/pul..." - silverstripe/silverstripe-textextraction - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 979586...b20738 )

by Daniel

created 2018-07-04 09:28 UTC

FileTextExtractor::for_file() B

↳ Parent: FileTextExtractor

Complexity

Conditions	8
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
nc	6
nop	1
dl	0
loc	25
rs	8.4444
c	0
b	0
f	0

<?php

namespace SilverStripe\TextExtraction\Extractor;

use SilverStripe\Assets\File;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\TextExtraction\Extractor\FileTextExtractor\Exception;

/**
 * A decorator for File or a subclass that provides a method for extracting full-text from the file's external contents.
 * @author mstephens
 */
abstract class FileTextExtractor
{
    use Configurable;
    use Injectable;

    /**
     * Set priority from 0-100.
     * The highest priority extractor for a given content type will be selected.
     *
     * @config
     * @var integer
     */
    private static $priority = 50;


    /**
     * Cache of extractor class names, sorted by priority
     *
     * @var array
     */
    protected static $sorted_extractor_classes = null;

    /**
     * Gets the list of prioritised extractor classes
     *
     * @return array
     */
    protected static function get_extractor_classes()
    {
        // Check cache
        if (self::$sorted_extractor_classes) {

            return self::$sorted_extractor_classes;
        }

        // Generate the sorted list of extractors on demand.
        $classes = ClassInfo::subclassesFor(__CLASS__);
        array_shift($classes);
        $classPriorities = [];

        foreach ($classes as $class) {
            $classPriorities[$class] = Config::inst()->get($class, 'priority');
        }
        arsort($classPriorities);

        // Save classes
        $sortedClasses = array_keys($classPriorities);
        return self::$sorted_extractor_classes = $sortedClasses;
    }

    /**
     * Get the text file extractor for the given class
     *
     * @param string $class
     * @return FileTextExtractor
     */
    protected static function get_extractor($class)
    {
        return Injector::inst()->get($class);
    }

    /**
     * Given a File object, decide which extractor instance to use to handle it
     *
     * @param File $file
     * @return FileTextExtractor|null
     */
    public static function for_file(File $file)
    {
        if (!$file) {

            return null;
        }

        $extension = $file->getExtension();
        $mime = $file->getMimeType();

        foreach (self::get_extractor_classes() as $className) {
            $extractor = self::get_extractor($className);

            // Skip unavailable extractors
            if (!$extractor->isAvailable()) {
                continue;
            }

            // Check extension
            if ($extension && $extractor->supportsExtension($extension)) {
                return $extractor;
            }

            // Check mime
            if ($mime && $extractor->supportsMime($mime)) {
                return $extractor;
            }
        }
    }

    /**
     * Some text extractors (like pdftotext) may require a physical file to read from, so write the current
     * file contents to a temp file and return its path
     *
     * @param File $file
     * @return string
     * @throws Exception
     */
    protected function getPathFromFile(File $file)
    {
        $path = tempnam(TEMP_PATH, 'pdftextextractor_');
        if (false === $path) {
            throw new Exception(static::class . '->getPathFromFile() could not allocate temporary file name');
        }

        // Append extension to temp file if one is set
        if ($file->getExtension()) {
            $path .= '.' . $file->getExtension();
        }

        // Remove any existing temp files with this name
        if (file_exists($path)) {
            unlink($path);
        }

        $bytesWritten = file_put_contents($path, $file->getStream());
        if (false === $bytesWritten) {
            throw new Exception(static::class . '->getPathFromFile() failed to write temporary file');
        }

        return $path;
    }

    /**
     * Checks if the extractor is supported on the current environment,
     * for example if the correct binaries or libraries are available.
     *
     * @return boolean
     */
    abstract public function isAvailable();

    /**
     * Determine if this extractor supports the given extension.
     * If support is determined by mime/type only, then this should return false.
     *
     * @param string $extension
     * @return boolean
     */
    abstract public function supportsExtension($extension);

    /**
     * Determine if this extractor supports the given mime type.
     * Will only be called if supportsExtension returns false.
     *
     * @param string $mime
     * @return boolean
     */
    abstract public function supportsMime($mime);

    /**
     * Given a File instance, extract the contents as text.
     *
     * @param File|string $file Either the File instance, or a file path for a file to load
     * @return string
     */
    abstract public function getContent($file);
}


1			<?php
2
3			namespace SilverStripe\TextExtraction\Extractor;
4
5			use SilverStripe\Assets\File;
6			use SilverStripe\Core\ClassInfo;
7			use SilverStripe\Core\Config\Config;
8			use SilverStripe\Core\Config\Configurable;
9			use SilverStripe\Core\Injector\Injectable;
10			use SilverStripe\Core\Injector\Injector;
11			use SilverStripe\TextExtraction\Extractor\FileTextExtractor\Exception;
12
13			/**
14			* A decorator for File or a subclass that provides a method for extracting full-text from the file's external contents.
15			* @author mstephens
16			*/
17			abstract class FileTextExtractor
18			{
19			use Configurable;
20			use Injectable;
21
22			/**
23			* Set priority from 0-100.
24			* The highest priority extractor for a given content type will be selected.
25			*
26			* @config
27			* @var integer
28			*/
29			private static $priority = 50;
			0 ignored issues – show introduced 2018-07-03 05:40 UTC by Report Bug Copy Issue Report The private property `$priority` is not used, and could be removed. Loading history...
30
31			/**
32			* Cache of extractor class names, sorted by priority
33			*
34			* @var array
35			*/
36			protected static $sorted_extractor_classes = null;
37
38			/**
39			* Gets the list of prioritised extractor classes
40			*
41			* @return array
42			*/
43			protected static function get_extractor_classes()
44			{
45			// Check cache
46			if (self::$sorted_extractor_classes) {
			0 ignored issues – show Bug Best Practice introduced 2018-07-03 05:40 UTC by Report Bug Copy Issue Report The expression `self::sorted_extractor_classes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
47			return self::$sorted_extractor_classes;
48			}
49
50			// Generate the sorted list of extractors on demand.
51			$classes = ClassInfo::subclassesFor(__CLASS__);
52			array_shift($classes);
53			$classPriorities = [];
54
55			foreach ($classes as $class) {
56			$classPriorities[$class] = Config::inst()->get($class, 'priority');
57			}
58			arsort($classPriorities);
59
60			// Save classes
61			$sortedClasses = array_keys($classPriorities);
62			return self::$sorted_extractor_classes = $sortedClasses;
63			}
64
65			/**
66			* Get the text file extractor for the given class
67			*
68			* @param string $class
69			* @return FileTextExtractor
70			*/
71			protected static function get_extractor($class)
72			{
73			return Injector::inst()->get($class);
74			}
75
76			/**
77			* Given a File object, decide which extractor instance to use to handle it
78			*
79			* @param File $file
80			* @return FileTextExtractor\|null
81			*/
82			public static function for_file(File $file)
83			{
84			if (!$file) {
			0 ignored issues – show introduced 2018-07-03 05:40 UTC by Report Bug Copy Issue Report `$file` is of type `SilverStripe\Assets\File`, thus it always evaluated to `true`. Loading history...
85			return null;
86			}
87
88			$extension = $file->getExtension();
89			$mime = $file->getMimeType();
90
91			foreach (self::get_extractor_classes() as $className) {
92			$extractor = self::get_extractor($className);
93
94			// Skip unavailable extractors
95			if (!$extractor->isAvailable()) {
96			continue;
97			}
98
99			// Check extension
100			if ($extension && $extractor->supportsExtension($extension)) {
101			return $extractor;
102			}
103
104			// Check mime
105			if ($mime && $extractor->supportsMime($mime)) {
106			return $extractor;
107			}
108			}
109			}
110
111			/**
112			* Some text extractors (like pdftotext) may require a physical file to read from, so write the current
113			* file contents to a temp file and return its path
114			*
115			* @param File $file
116			* @return string
117			* @throws Exception
118			*/
119			protected function getPathFromFile(File $file)
120			{
121			$path = tempnam(TEMP_PATH, 'pdftextextractor_');
122			if (false === $path) {
123			throw new Exception(static::class . '->getPathFromFile() could not allocate temporary file name');
124			}
125
126			// Append extension to temp file if one is set
127			if ($file->getExtension()) {
128			$path .= '.' . $file->getExtension();
129			}
130
131			// Remove any existing temp files with this name
132			if (file_exists($path)) {
133			unlink($path);
134			}
135
136			$bytesWritten = file_put_contents($path, $file->getStream());
137			if (false === $bytesWritten) {
138			throw new Exception(static::class . '->getPathFromFile() failed to write temporary file');
139			}
140
141			return $path;
142			}
143
144			/**
145			* Checks if the extractor is supported on the current environment,
146			* for example if the correct binaries or libraries are available.
147			*
148			* @return boolean
149			*/
150			abstract public function isAvailable();
151
152			/**
153			* Determine if this extractor supports the given extension.
154			* If support is determined by mime/type only, then this should return false.
155			*
156			* @param string $extension
157			* @return boolean
158			*/
159			abstract public function supportsExtension($extension);
160
161			/**
162			* Determine if this extractor supports the given mime type.
163			* Will only be called if supportsExtension returns false.
164			*
165			* @param string $mime
166			* @return boolean
167			*/
168			abstract public function supportsMime($mime);
169
170			/**
171			* Given a File instance, extract the contents as text.
172			*
173			* @param File\|string $file Either the File instance, or a file path for a file to load
174			* @return string
175			*/
176			abstract public function getContent($file);
177			}
178

silverstripe / silverstripe-textextraction

Push — master ( 979586...b20738 )

FileTextExtractor::for_file() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like