Song - Code Metrics - Inspection of "Gcp" - phanan/koel - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Pull Request — master (#590)

unknown

created 2017-07-15 14:10 UTC

Song B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	380
Duplicated Lines	5.26 %

Coupling/Cohesion

Components	4
Dependencies	12

Importance

Changes

Metric	Value
wmc	41
lcom	4
cbo	12
dl	20
loc	380
c	0
b	0
f	0
rs	8.2769

19 Methods

Rating	Name	Duplication	Size	Complexity
A	artist()	0	4	1
A	album()	0	4	1
A	playlists()	0	4	1
A	scrobble()	0	20	4
A	byPath()	0	4	1
D	updateInfo()	0	39	9
B	updateSingle()	0	41	4
A	scopeInDirectory()	0	7	1
A	getFavorites()	0	9	2
B	getObjectStoragePublicUrl()	0	25	3
A	getGcpObjectStoragePublicUrl()	0	17	3
A	getRelatedYouTubeVideos()	0	4	1
A	setTitleAttribute()	0	4	1
A	getTitleAttribute()	0	4	2
A	getLyricsAttribute()	0	7	1
A	isS3ObjectAttribute()	0	4	1
A	getS3ParamsAttribute()	10	10	2
A	isGCPObjectAttribute()	0	4	1
A	getGCPParamsAttribute()	10	10	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Song often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Song, and based on these observations, apply Extract Interface, too.

<?php

namespace App\Models;

use App\Events\LibraryChanged;
use App\Traits\SupportsDeleteWhereIDsNotIn;
use AWS;
use Aws\AwsClient;
use Cache;
use Illuminate\Database\Eloquent\Model;
use Lastfm;
use YouTube;
use Google\Cloud\Storage\StorageClient;
use Carbon\Carbon;

/**
 * @property string path
 * @property string title
 * @property Album  album
 * @property Artist artist
 * @property string s3_params
 * @property float  length
 * @property string lyrics
 * @property int    track
 * @property int    album_id
 * @property int    id
 * @property int    artist_id
 */
class Song extends Model
{
    use SupportsDeleteWhereIDsNotIn;

    protected $guarded = [];

    /**
     * Attributes to be hidden from JSON outputs.
     * Here we specify to hide lyrics as well to save some bandwidth (actually, lots of it).
     * Lyrics can then be queried on demand.
     *
     * @var array
     */
    protected $hidden = ['lyrics', 'updated_at', 'path', 'mtime'];

    /**
     * @var array
     */
    protected $casts = [
        'length' => 'float',
        'mtime' => 'int',
        'track' => 'int',
    ];

    /**
     * Indicates if the IDs are auto-incrementing.
     *
     * @var bool
     */
    public $incrementing = false;

    public function artist()
    {
        return $this->belongsTo(Artist::class);
    }

    public function album()
    {
        return $this->belongsTo(Album::class);
    }

    public function playlists()
    {
        return $this->belongsToMany(Playlist::class);
    }

    /**
     * Scrobble the song using Last.fm service.
     *
     * @param User   $user
     * @param string $timestamp The UNIX timestamp in which the song started playing.
     *
     * @return mixed
     */
    public function scrobble(User $user, $timestamp)
    {
        // Don't scrobble the unknown guys. No one knows them.
        if ($this->artist->is_unknown) {
            return false;
        }

        // If the current user hasn't connected to Last.fm, don't do shit.
        if (!$user->connectedToLastfm()) {
            return false;
        }

        return Lastfm::scrobble(
            $this->artist->name,
            $this->title,
            $timestamp,
            $this->album->name === Album::UNKNOWN_NAME ? '' : $this->album->name,
            $user->lastfm_session_key
        );
    }

    /**
     * Get a Song record using its path.
     *
     * @param string $path
     *
     * @return Song|null
     */
    public static function byPath($path)
    {
        return self::find(File::getHash($path));
    }

    /**
     * Update song info.
     *
     * @param array $ids
     * @param array $data The data array, with these supported fields:
     *                    - title
     *                    - artistName
     *                    - albumName
     *                    - lyrics
     *                    All of these are optional, in which case the info will not be changed
     *                    (except for lyrics, which will be emptied).
     *
     * @return array
     */
    public static function updateInfo($ids, $data)
    {
        /*
         * A collection of the updated songs.
         *
         * @var \Illuminate\Support\Collection
         */
        $updatedSongs = collect();

        $ids = (array) $ids;
        // If we're updating only one song, take into account the title, lyrics, and track number.
        $single = count($ids) === 1;

        foreach ($ids as $id) {
            if (!$song = self::with('album', 'album.artist')->find($id)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                continue;
            }

            $updatedSongs->push($song->updateSingle(
                $single ? trim($data['title']) : $song->title,
                trim($data['albumName'] ?: $song->album->name),
                trim($data['artistName']) ?: $song->artist->name,
                $single ? trim($data['lyrics']) : $song->lyrics,
                $single ? (int) $data['track'] : $song->track,
                (int) $data['compilationState']
            ));
        }

        // Our library may have been changed. Broadcast an event to tidy it up if need be.
        if ($updatedSongs->count()) {
            event(new LibraryChanged());
        }

        return [
            'artists' => Artist::whereIn('id', $updatedSongs->pluck('artist_id'))->get(),
            'albums' => Album::whereIn('id', $updatedSongs->pluck('album_id'))->get(),
            'songs' => $updatedSongs,
        ];
    }

    /**
     * Update a single song's info.
     *
     * @param string $title
     * @param string $albumName
     * @param string $artistName
     * @param string $lyrics
     * @param int    $track
     * @param int    $compilationState
     *
     * @return self
     */
    public function updateSingle($title, $albumName, $artistName, $lyrics, $track, $compilationState)
    {
        if ($artistName === Artist::VARIOUS_NAME) {
            // If the artist name is "Various Artists", it's a compilation song no matter what.
            $compilationState = 1;
            // and since we can't determine the real contributing artist, it's "Unknown"
            $artistName = Artist::UNKNOWN_NAME;
        }

        $artist = Artist::get($artistName);

        switch ($compilationState) {
            case 1: // ALL, or forcing compilation status to be Yes
                $isCompilation = true;
                break;
            case 2: // Keep current compilation status
                $isCompilation = $this->album->artist_id === Artist::VARIOUS_ID;
                break;
            default:
                $isCompilation = false;
                break;
        }

        $album = Album::get($artist, $albumName, $isCompilation);

        $this->artist_id = $artist->id;
        $this->album_id = $album->id;
        $this->title = $title;
        $this->lyrics = $lyrics;
        $this->track = $track;

        $this->save();

        // Clean up unnecessary data from the object
        unset($this->album);
        unset($this->artist);
        // and make sure the lyrics is shown
        $this->makeVisible('lyrics');

        return $this;
    }

    /**
     * Scope a query to only include songs in a given directory.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string                                $path  Full path of the directory
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeInDirectory($query, $path)
    {
        // Make sure the path ends with a directory separator.
        $path = rtrim(trim($path), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;

        return $query->where('path', 'LIKE', "$path%");
    }

    /**
     * Get all songs favored by a user.
     *
     * @param User $user
     * @param bool $toArray
     *
     * @return \Illuminate\Database\Eloquent\Collection|array
     */
    public static function getFavorites(User $user, $toArray = false)
    {
        $songs = Interaction::whereUserIdAndLike($user->id, true)
            ->with('song')
            ->get()
            ->pluck('song');

        return $toArray ? $songs->toArray() : $songs;
    }

    /**
     * Get the song's Object Storage url for streaming or downloading.
     *
     * @param AwsClient $s3
     *
     * @return string
     */
    public function getObjectStoragePublicUrl(AwsClient $s3 = null)
    {
        // If we have a cached version, just return it.
        if ($cached = Cache::get("OSUrl/{$this->id}")) {
            return $cached;
        }

        // Otherwise, we query S3 for the presigned request.
        if (!$s3) {
            $s3 = AWS::createClient('s3');
        }

        $cmd = $s3->getCommand('GetObject', [
            'Bucket' => $this->s3_params['bucket'],
            'Key' => $this->s3_params['key'],
        ]);

        // Here we specify that the request is valid for 1 hour.
        // We'll also cache the public URL for future reuse.
        $request = $s3->createPresignedRequest($cmd, '+1 hour');
        $url = (string) $request->getUri();
        Cache::put("OSUrl/{$this->id}", $url, 60);

        return $url;
    }

    public function getGcpObjectStoragePublicUrl(StorageClient $gcs = null)
    {
        // If we have a cached version, just return it.
        if ($cached = Cache::get("OSUrl/{$this->id}")) {
            return $cached;
        }
        if (!$gcs) {
            $gcs = new StorageClient([]);
        }
        $bucket = $gcs->bucket($this->gcp_params['bucket']);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $object = $bucket->object($this->gcp_params['key']);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $options = array();
        $options['keyFilePath'] = env('GCS_KEY_FILE_PATH');
        $url = $object->signedUrl(Carbon::now()->addHours(24)->timestamp, $options);
        Cache::put("OSUrl/{$this->id}", $url, 60);
        return $url;
    }



    /**
     * Get the YouTube videos related to this song.
     *
     * @param string $youTubePageToken The YouTube page token, for pagination purpose.
     *
     * @return @return object|false

     */
    public function getRelatedYouTubeVideos($youTubePageToken = '')
    {
        return YouTube::searchVideosRelatedToSong($this, $youTubePageToken);
    }

    /**
     * Sometimes the tags extracted from getID3 are HTML entity encoded.
     * This makes sure they are always sane.
     *
     * @param $value
     */
    public function setTitleAttribute($value)
    {
        $this->attributes['title'] = html_entity_decode($value);
    }

    /**
     * Some songs don't have a title.
     * Fall back to the file name (without extension) for such.
     *
     * @param  $value
     *
     * @return string
     */
    public function getTitleAttribute($value)
    {
        return $value ?: pathinfo($this->path, PATHINFO_FILENAME);
    }

    /**
     * Prepare the lyrics for displaying.
     *
     * @param $value
     *
     * @return string
     */
    public function getLyricsAttribute($value)
    {
        // We don't use nl2br() here, because the function actually preserves line breaks -
        // it just _appends_ a "<br />" after each of them. This would cause our client
        // implementation of br2nl to fail with duplicated line breaks.
        return str_replace(["\r\n", "\r", "\n"], '<br />', $value);
    }

    /**
     * Determine if the song is an AWS S3 Object.
     *
     * @return bool
     */
    public function isS3ObjectAttribute()
    {
        return starts_with($this->path, 's3://');
    }

    /**
     * Get the bucket and key name of an S3 object.
     *
     * @return bool|array
     */
    public function getS3ParamsAttribute()

    {
        if (!preg_match('/^s3:\\/\\/(.*)/', $this->path, $matches)) {
            return false;
        }

        list($bucket, $key) = explode('/', $matches[1], 2);

        return compact('bucket', 'key');
    }

    public function isGCPObjectAttribute()
    {
        return starts_with($this->path, 'gs://');
    }

    /**
     * Get the bucket and key name of an GCS object.
     *
     * @return bool|array
     */
    public function getGCPParamsAttribute()

    {
        if (!preg_match('/^gs:\\/\\/(.*)/', $this->path, $matches)) {
            return false;
        }

        list($bucket, $key) = explode('/', $matches[1], 2);

        return compact('bucket', 'key');
    }	
}


1		<?php
2
3		namespace App\Models;
4
5		use App\Events\LibraryChanged;
6		use App\Traits\SupportsDeleteWhereIDsNotIn;
7		use AWS;
8		use Aws\AwsClient;
9		use Cache;
10		use Illuminate\Database\Eloquent\Model;
11		use Lastfm;
12		use YouTube;
13		use Google\Cloud\Storage\StorageClient;
14		use Carbon\Carbon;
15
16		/**
17		* @property string path
18		* @property string title
19		* @property Album album
20		* @property Artist artist
21		* @property string s3_params
22		* @property float length
23		* @property string lyrics
24		* @property int track
25		* @property int album_id
26		* @property int id
27		* @property int artist_id
28		*/
29		class Song extends Model
30		{
31		use SupportsDeleteWhereIDsNotIn;
32
33		protected $guarded = [];
34
35		/**
36		* Attributes to be hidden from JSON outputs.
37		* Here we specify to hide lyrics as well to save some bandwidth (actually, lots of it).
38		* Lyrics can then be queried on demand.
39		*
40		* @var array
41		*/
42		protected $hidden = ['lyrics', 'updated_at', 'path', 'mtime'];
43
44		/**
45		* @var array
46		*/
47		protected $casts = [
48		'length' => 'float',
49		'mtime' => 'int',
50		'track' => 'int',
51		];
52
53		/**
54		* Indicates if the IDs are auto-incrementing.
55		*
56		* @var bool
57		*/
58		public $incrementing = false;
59
60		public function artist()
61		{
62		return $this->belongsTo(Artist::class);
63		}
64
65		public function album()
66		{
67		return $this->belongsTo(Album::class);
68		}
69
70		public function playlists()
71		{
72		return $this->belongsToMany(Playlist::class);
73		}
74
75		/**
76		* Scrobble the song using Last.fm service.
77		*
78		* @param User $user
79		* @param string $timestamp The UNIX timestamp in which the song started playing.
80		*
81		* @return mixed
82		*/
83		public function scrobble(User $user, $timestamp)
84		{
85		// Don't scrobble the unknown guys. No one knows them.
86		if ($this->artist->is_unknown) {
87		return false;
88		}
89
90		// If the current user hasn't connected to Last.fm, don't do shit.
91		if (!$user->connectedToLastfm()) {
92		return false;
93		}
94
95		return Lastfm::scrobble(
96		$this->artist->name,
97		$this->title,
98		$timestamp,
99		$this->album->name === Album::UNKNOWN_NAME ? '' : $this->album->name,
100		$user->lastfm_session_key
101		);
102		}
103
104		/**
105		* Get a Song record using its path.
106		*
107		* @param string $path
108		*
109		* @return Song\|null
110		*/
111		public static function byPath($path)
112		{
113		return self::find(File::getHash($path));
114		}
115
116		/**
117		* Update song info.
118		*
119		* @param array $ids
120		* @param array $data The data array, with these supported fields:
121		* - title
122		* - artistName
123		* - albumName
124		* - lyrics
125		* All of these are optional, in which case the info will not be changed
126		* (except for lyrics, which will be emptied).
127		*
128		* @return array
129		*/
130		public static function updateInfo($ids, $data)
131		{
132		/*
133		* A collection of the updated songs.
134		*
135		* @var \Illuminate\Support\Collection
136		*/
137		$updatedSongs = collect();
138
139		$ids = (array) $ids;
140		// If we're updating only one song, take into account the title, lyrics, and track number.
141		$single = count($ids) === 1;
142
143		foreach ($ids as $id) {
144		if (!$song = self::with('album', 'album.artist')->find($id)) {
		0 ignored issues – show Bug introduced 2017-06-03 00:27 UTC by Report Bug Copy Issue Report The method `find` does only exist in `Illuminate\Database\Eloquent\Builder`, but not in `Illuminate\Database\Eloquent\Model`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
145		continue;
146		}
147
148		$updatedSongs->push($song->updateSingle(
149		$single ? trim($data['title']) : $song->title,
150		trim($data['albumName'] ?: $song->album->name),
151		trim($data['artistName']) ?: $song->artist->name,
152		$single ? trim($data['lyrics']) : $song->lyrics,
153		$single ? (int) $data['track'] : $song->track,
154		(int) $data['compilationState']
155		));
156		}
157
158		// Our library may have been changed. Broadcast an event to tidy it up if need be.
159		if ($updatedSongs->count()) {
160		event(new LibraryChanged());
161		}
162
163		return [
164		'artists' => Artist::whereIn('id', $updatedSongs->pluck('artist_id'))->get(),
165		'albums' => Album::whereIn('id', $updatedSongs->pluck('album_id'))->get(),
166		'songs' => $updatedSongs,
167		];
168		}
169
170		/**
171		* Update a single song's info.
172		*
173		* @param string $title
174		* @param string $albumName
175		* @param string $artistName
176		* @param string $lyrics
177		* @param int $track
178		* @param int $compilationState
179		*
180		* @return self
181		*/
182		public function updateSingle($title, $albumName, $artistName, $lyrics, $track, $compilationState)
183		{
184		if ($artistName === Artist::VARIOUS_NAME) {
185		// If the artist name is "Various Artists", it's a compilation song no matter what.
186		$compilationState = 1;
187		// and since we can't determine the real contributing artist, it's "Unknown"
188		$artistName = Artist::UNKNOWN_NAME;
189		}
190
191		$artist = Artist::get($artistName);
192
193		switch ($compilationState) {
194		case 1: // ALL, or forcing compilation status to be Yes
195		$isCompilation = true;
196		break;
197		case 2: // Keep current compilation status
198		$isCompilation = $this->album->artist_id === Artist::VARIOUS_ID;
199		break;
200		default:
201		$isCompilation = false;
202		break;
203		}
204
205		$album = Album::get($artist, $albumName, $isCompilation);
206
207		$this->artist_id = $artist->id;
208		$this->album_id = $album->id;
209		$this->title = $title;
210		$this->lyrics = $lyrics;
211		$this->track = $track;
212
213		$this->save();
214
215		// Clean up unnecessary data from the object
216		unset($this->album);
217		unset($this->artist);
218		// and make sure the lyrics is shown
219		$this->makeVisible('lyrics');
220
221		return $this;
222		}
223
224		/**
225		* Scope a query to only include songs in a given directory.
226		*
227		* @param \Illuminate\Database\Eloquent\Builder $query
228		* @param string $path Full path of the directory
229		*
230		* @return \Illuminate\Database\Eloquent\Builder
231		*/
232		public function scopeInDirectory($query, $path)
233		{
234		// Make sure the path ends with a directory separator.
235		$path = rtrim(trim($path), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
236
237		return $query->where('path', 'LIKE', "$path%");
238		}
239
240		/**
241		* Get all songs favored by a user.
242		*
243		* @param User $user
244		* @param bool $toArray
245		*
246		* @return \Illuminate\Database\Eloquent\Collection\|array
247		*/
248		public static function getFavorites(User $user, $toArray = false)
249		{
250		$songs = Interaction::whereUserIdAndLike($user->id, true)
251		->with('song')
252		->get()
253		->pluck('song');
254
255		return $toArray ? $songs->toArray() : $songs;
256		}
257
258		/**
259		* Get the song's Object Storage url for streaming or downloading.
260		*
261		* @param AwsClient $s3
262		*
263		* @return string
264		*/
265		public function getObjectStoragePublicUrl(AwsClient $s3 = null)
266		{
267		// If we have a cached version, just return it.
268		if ($cached = Cache::get("OSUrl/{$this->id}")) {
269		return $cached;
270		}
271
272		// Otherwise, we query S3 for the presigned request.
273		if (!$s3) {
274		$s3 = AWS::createClient('s3');
275		}
276
277		$cmd = $s3->getCommand('GetObject', [
278		'Bucket' => $this->s3_params['bucket'],
279		'Key' => $this->s3_params['key'],
280		]);
281
282		// Here we specify that the request is valid for 1 hour.
283		// We'll also cache the public URL for future reuse.
284		$request = $s3->createPresignedRequest($cmd, '+1 hour');
285		$url = (string) $request->getUri();
286		Cache::put("OSUrl/{$this->id}", $url, 60);
287
288		return $url;
289		}
290
291		public function getGcpObjectStoragePublicUrl(StorageClient $gcs = null)
292		{
293		// If we have a cached version, just return it.
294		if ($cached = Cache::get("OSUrl/{$this->id}")) {
295		return $cached;
296		}
297		if (!$gcs) {
298		$gcs = new StorageClient([]);
299		}
300		$bucket = $gcs->bucket($this->gcp_params['bucket']);
		0 ignored issues – show Documentation introduced 2017-07-15 14:21 UTC by Report Bug Copy Issue Report The property `gcp_params` does not exist on `object<App\Models\Song>`. Since you implemented `__get`, maybe consider adding a @property annotation. Since your code implements the magic getter `_get`, this function will be called for any read access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } If the property has read access only, you can use the @property-read annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
301		$object = $bucket->object($this->gcp_params['key']);
		0 ignored issues – show Documentation introduced 2017-07-15 14:21 UTC by Report Bug Copy Issue Report The property `gcp_params` does not exist on `object<App\Models\Song>`. Since you implemented `__get`, maybe consider adding a @property annotation. Since your code implements the magic getter `_get`, this function will be called for any read access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } If the property has read access only, you can use the @property-read annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
302		$options = array();
303		$options['keyFilePath'] = env('GCS_KEY_FILE_PATH');
304		$url = $object->signedUrl(Carbon::now()->addHours(24)->timestamp, $options);
305		Cache::put("OSUrl/{$this->id}", $url, 60);
306		return $url;
307		}
308
309
310
311		/**
312		* Get the YouTube videos related to this song.
313		*
314		* @param string $youTubePageToken The YouTube page token, for pagination purpose.
315		*
316		* @return @return object\|false
		0 ignored issues – show Documentation introduced 2017-06-03 00:27 UTC by Report Bug Copy Issue Report The doc-type `@return` could not be parsed: Unknown type name "@return" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
317		*/
318		public function getRelatedYouTubeVideos($youTubePageToken = '')
319		{
320		return YouTube::searchVideosRelatedToSong($this, $youTubePageToken);
321		}
322
323		/**
324		* Sometimes the tags extracted from getID3 are HTML entity encoded.
325		* This makes sure they are always sane.
326		*
327		* @param $value
328		*/
329		public function setTitleAttribute($value)
330		{
331		$this->attributes['title'] = html_entity_decode($value);
332		}
333
334		/**
335		* Some songs don't have a title.
336		* Fall back to the file name (without extension) for such.
337		*
338		* @param $value
339		*
340		* @return string
341		*/
342		public function getTitleAttribute($value)
343		{
344		return $value ?: pathinfo($this->path, PATHINFO_FILENAME);
345		}
346
347		/**
348		* Prepare the lyrics for displaying.
349		*
350		* @param $value
351		*
352		* @return string
353		*/
354		public function getLyricsAttribute($value)
355		{
356		// We don't use nl2br() here, because the function actually preserves line breaks -
357		// it just _appends_ a "<br />" after each of them. This would cause our client
358		// implementation of br2nl to fail with duplicated line breaks.
359		return str_replace(["\r\n", "\r", "\n"], '<br />', $value);
360		}
361
362		/**
363		* Determine if the song is an AWS S3 Object.
364		*
365		* @return bool
366		*/
367		public function isS3ObjectAttribute()
368		{
369		return starts_with($this->path, 's3://');
370		}
371
372		/**
373		* Get the bucket and key name of an S3 object.
374		*
375		* @return bool\|array
376		*/
377	View Code Duplication	public function getS3ParamsAttribute()
		0 ignored issues – show Duplication introduced 2017-07-15 14:21 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
378		{
379		if (!preg_match('/^s3:\\/\\/(.*)/', $this->path, $matches)) {
380		return false;
381		}
382
383		list($bucket, $key) = explode('/', $matches[1], 2);
384
385		return compact('bucket', 'key');
386		}
387
388		public function isGCPObjectAttribute()
389		{
390		return starts_with($this->path, 'gs://');
391		}
392
393		/**
394		* Get the bucket and key name of an GCS object.
395		*
396		* @return bool\|array
397		*/
398	View Code Duplication	public function getGCPParamsAttribute()
		0 ignored issues – show Duplication introduced 2017-07-15 14:21 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
399		{
400		if (!preg_match('/^gs:\\/\\/(.*)/', $this->path, $matches)) {
401		return false;
402		}
403
404		list($bucket, $key) = explode('/', $matches[1], 2);
405
406		return compact('bucket', 'key');
407		}
408		}
409

phanan / koel