FeedItem_Common::get_enclosures() - Code Metrics - codysnider/tt-rss - Measure and Improve Code Quality continuously with Scrutinizer

FeedItem_Common::get_enclosures() C
last analyzed 2019-12-23 07:25 UTC

↳ Parent: FeedItem_Common

Complexity

Conditions	12
Paths	80

Size

Total Lines	74
Code Lines	46

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
eloc	46
c	0
b	0
f	0
nc	80
nop	0
dl	0
loc	74
rs	6.9666

How to fix Long Method Complexity

<?php
abstract class FeedItem_Common extends FeedItem {
    protected $elem;
    protected $xpath;
    protected $doc;

    public function __construct($elem, $doc, $xpath) {
        $this->elem = $elem;
        $this->xpath = $xpath;
        $this->doc = $doc;

        try {

            $source = $elem->getElementsByTagName("source")->item(0);

            // we don't need <source> element
            if ($source) {
                            $elem->removeChild($source);
            }
        } catch (DOMException $e) {
            //
        }
    }

    public function get_element() {
        return $this->elem;
    }

    public function get_author() {
        $author = $this->elem->getElementsByTagName("author")->item(0);

        if ($author) {
            $name = $author->getElementsByTagName("name")->item(0);

            if ($name) {
                return clean($name->nodeValue);
            }

            $email = $author->getElementsByTagName("email")->item(0);

            if ($email) {
                return clean($email->nodeValue);
            }

            if ($author->nodeValue) {
                            return clean($author->nodeValue);
            }
        }

        $author_elems = $this->xpath->query("dc:creator", $this->elem);
        $authors = [];

        foreach ($author_elems as $author) {
            array_push($authors, clean($author->nodeValue));
        }

        return implode(", ", $authors);
    }

    public function get_comments_url() {
        //RSS only. Use a query here to avoid namespace clashes (e.g. with slash).
        //might give a wrong result if a default namespace was declared (possible with XPath 2.0)
        $com_url = $this->xpath->query("comments", $this->elem)->item(0);

        if ($com_url) {
                    return clean($com_url->nodeValue);
        }

        //Atom Threading Extension (RFC 4685) stuff. Could be used in RSS feeds, so it's in common.
        //'text/html' for type is too restrictive?
        $com_url = $this->xpath->query("atom:link[@rel='replies' and contains(@type,'text/html')]/@href", $this->elem)->item(0);

        if ($com_url) {
                    return clean($com_url->nodeValue);
        }
    }

    public function get_comments_count() {
        //also query for ATE stuff here
        $query = "slash:comments|thread:total|atom:link[@rel='replies']/@thread:count";
        $comments = $this->xpath->query($query, $this->elem)->item(0);

        if ($comments) {
            return clean($comments->nodeValue);
        }
    }

    // this is common for both Atom and RSS types and deals with various media: elements
    public function get_enclosures() {
        $encs = [];

        $enclosures = $this->xpath->query("media:content", $this->elem);

        foreach ($enclosures as $enclosure) {
            $enc = new FeedEnclosure();

            $enc->type = clean($enclosure->getAttribute("type"));
            $enc->link = clean($enclosure->getAttribute("url"));
            $enc->length = clean($enclosure->getAttribute("length"));
            $enc->height = clean($enclosure->getAttribute("height"));
            $enc->width = clean($enclosure->getAttribute("width"));

            $medium = clean($enclosure->getAttribute("medium"));
            if (!$enc->type && $medium) {
                $enc->type = strtolower("$medium/generic");
            }

            $desc = $this->xpath->query("media:description", $enclosure)->item(0);
            if ($desc) {
                $enc->title = clean($desc->nodeValue);
            }

            array_push($encs, $enc);
        }

        $enclosures = $this->xpath->query("media:group", $this->elem);

        foreach ($enclosures as $enclosure) {
            $enc = new FeedEnclosure();

            $content = $this->xpath->query("media:content", $enclosure)->item(0);

            if ($content) {
                $enc->type = clean($content->getAttribute("type"));
                $enc->link = clean($content->getAttribute("url"));
                $enc->length = clean($content->getAttribute("length"));
                $enc->height = clean($content->getAttribute("height"));
                $enc->width = clean($content->getAttribute("width"));

                $medium = clean($content->getAttribute("medium"));
                if (!$enc->type && $medium) {
                    $enc->type = strtolower("$medium/generic");
                }

                $desc = $this->xpath->query("media:description", $content)->item(0);
                if ($desc) {
                    $enc->title = clean($desc->nodeValue);
                } else {
                    $desc = $this->xpath->query("media:description", $enclosure)->item(0);
                    if ($desc) {
                        $enc->title = clean($desc->nodeValue);
                    }
                }

                array_push($encs, $enc);
            }
        }

        $enclosures = $this->xpath->query("media:thumbnail", $this->elem);

        foreach ($enclosures as $enclosure) {
            $enc = new FeedEnclosure();

            $enc->type = "image/generic";
            $enc->link = clean($enclosure->getAttribute("url"));
            $enc->height = clean($enclosure->getAttribute("height"));
            $enc->width = clean($enclosure->getAttribute("width"));

            array_push($encs, $enc);
        }

        return $encs;
    }

    public function count_children($node) {
        return $node->getElementsByTagName("*")->length;
    }

    public function subtree_or_text($node) {
        if ($this->count_children($node) == 0) {
            return $node->nodeValue;
        } else {
            return $node->c14n();
        }
    }

    public static function normalize_categories($cats) {

        $tmp = [];

        foreach ($cats as $rawcat) {
            $tmp = array_merge($tmp, explode(",", $rawcat));
        }

        $tmp = array_map(function($srccat) {
            $cat = clean(trim(mb_strtolower($srccat)));

            // we don't support numeric tags
            if (is_numeric($cat)) {
                            $cat = 't:'.$cat;
            }

            $cat = preg_replace('/[,\'\"]/', "", $cat);

            if (DB_TYPE == "mysql") {

                $cat = preg_replace('/[\x{10000}-\x{10FFFF}]/u', "\xEF\xBF\xBD", $cat);
            }

            if (mb_strlen($cat) > 250) {
                            $cat = mb_substr($cat, 0, 250);
            }

            return $cat;
        }, $tmp);

        asort($tmp);

        return array_unique($tmp);
    }
}


1			<?php
2			abstract class FeedItem_Common extends FeedItem {
3			protected $elem;
4			protected $xpath;
5			protected $doc;
6
7			public function __construct($elem, $doc, $xpath) {
8			$this->elem = $elem;
9			$this->xpath = $xpath;
10			$this->doc = $doc;
11
12			try {
13
14			$source = $elem->getElementsByTagName("source")->item(0);
15
16			// we don't need <source> element
17			if ($source) {
18			$elem->removeChild($source);
19			}
20			} catch (DOMException $e) {
21			//
22			}
23			}
24
25			public function get_element() {
26			return $this->elem;
27			}
28
29			public function get_author() {
30			$author = $this->elem->getElementsByTagName("author")->item(0);
31
32			if ($author) {
33			$name = $author->getElementsByTagName("name")->item(0);
34
35			if ($name) {
36			return clean($name->nodeValue);
37			}
38
39			$email = $author->getElementsByTagName("email")->item(0);
40
41			if ($email) {
42			return clean($email->nodeValue);
43			}
44
45			if ($author->nodeValue) {
46			return clean($author->nodeValue);
47			}
48			}
49
50			$author_elems = $this->xpath->query("dc:creator", $this->elem);
51			$authors = [];
52
53			foreach ($author_elems as $author) {
54			array_push($authors, clean($author->nodeValue));
55			}
56
57			return implode(", ", $authors);
58			}
59
60			public function get_comments_url() {
61			//RSS only. Use a query here to avoid namespace clashes (e.g. with slash).
62			//might give a wrong result if a default namespace was declared (possible with XPath 2.0)
63			$com_url = $this->xpath->query("comments", $this->elem)->item(0);
64
65			if ($com_url) {
66			return clean($com_url->nodeValue);
67			}
68
69			//Atom Threading Extension (RFC 4685) stuff. Could be used in RSS feeds, so it's in common.
70			//'text/html' for type is too restrictive?
71			$com_url = $this->xpath->query("atom:link[@rel='replies' and contains(@type,'text/html')]/@href", $this->elem)->item(0);
72
73			if ($com_url) {
74			return clean($com_url->nodeValue);
75			}
76			}
77
78			public function get_comments_count() {
79			//also query for ATE stuff here
80			$query = "slash:comments\|thread:total\|atom:link[@rel='replies']/@thread:count";
81			$comments = $this->xpath->query($query, $this->elem)->item(0);
82
83			if ($comments) {
84			return clean($comments->nodeValue);
85			}
86			}
87
88			// this is common for both Atom and RSS types and deals with various media: elements
89			public function get_enclosures() {
90			$encs = [];
91
92			$enclosures = $this->xpath->query("media:content", $this->elem);
93
94			foreach ($enclosures as $enclosure) {
95			$enc = new FeedEnclosure();
96
97			$enc->type = clean($enclosure->getAttribute("type"));
98			$enc->link = clean($enclosure->getAttribute("url"));
99			$enc->length = clean($enclosure->getAttribute("length"));
100			$enc->height = clean($enclosure->getAttribute("height"));
101			$enc->width = clean($enclosure->getAttribute("width"));
102
103			$medium = clean($enclosure->getAttribute("medium"));
104			if (!$enc->type && $medium) {
105			$enc->type = strtolower("$medium/generic");
106			}
107
108			$desc = $this->xpath->query("media:description", $enclosure)->item(0);
109			if ($desc) {
110			$enc->title = clean($desc->nodeValue);
111			}
112
113			array_push($encs, $enc);
114			}
115
116			$enclosures = $this->xpath->query("media:group", $this->elem);
117
118			foreach ($enclosures as $enclosure) {
119			$enc = new FeedEnclosure();
120
121			$content = $this->xpath->query("media:content", $enclosure)->item(0);
122
123			if ($content) {
124			$enc->type = clean($content->getAttribute("type"));
125			$enc->link = clean($content->getAttribute("url"));
126			$enc->length = clean($content->getAttribute("length"));
127			$enc->height = clean($content->getAttribute("height"));
128			$enc->width = clean($content->getAttribute("width"));
129
130			$medium = clean($content->getAttribute("medium"));
131			if (!$enc->type && $medium) {
132			$enc->type = strtolower("$medium/generic");
133			}
134
135			$desc = $this->xpath->query("media:description", $content)->item(0);
136			if ($desc) {
137			$enc->title = clean($desc->nodeValue);
138			} else {
139			$desc = $this->xpath->query("media:description", $enclosure)->item(0);
140			if ($desc) {
141			$enc->title = clean($desc->nodeValue);
142			}
143			}
144
145			array_push($encs, $enc);
146			}
147			}
148
149			$enclosures = $this->xpath->query("media:thumbnail", $this->elem);
150
151			foreach ($enclosures as $enclosure) {
152			$enc = new FeedEnclosure();
153
154			$enc->type = "image/generic";
155			$enc->link = clean($enclosure->getAttribute("url"));
156			$enc->height = clean($enclosure->getAttribute("height"));
157			$enc->width = clean($enclosure->getAttribute("width"));
158
159			array_push($encs, $enc);
160			}
161
162			return $encs;
163			}
164
165			public function count_children($node) {
166			return $node->getElementsByTagName("*")->length;
167			}
168
169			public function subtree_or_text($node) {
170			if ($this->count_children($node) == 0) {
171			return $node->nodeValue;
172			} else {
173			return $node->c14n();
174			}
175			}
176
177			public static function normalize_categories($cats) {
178
179			$tmp = [];
180
181			foreach ($cats as $rawcat) {
182			$tmp = array_merge($tmp, explode(",", $rawcat));
183			}
184
185			$tmp = array_map(function($srccat) {
186			$cat = clean(trim(mb_strtolower($srccat)));
187
188			// we don't support numeric tags
189			if (is_numeric($cat)) {
190			$cat = 't:'.$cat;
191			}
192
193			$cat = preg_replace('/[,\'\"]/', "", $cat);
194
195			if (DB_TYPE == "mysql") {
			0 ignored issues – show Bug introduced 2019-12-19 19:08 UTC by Report Bug Copy Issue Report The constant `DB_TYPE` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
196			$cat = preg_replace('/[\x{10000}-\x{10FFFF}]/u', "\xEF\xBF\xBD", $cat);
197			}
198
199			if (mb_strlen($cat) > 250) {
200			$cat = mb_substr($cat, 0, 250);
201			}
202
203			return $cat;
204			}, $tmp);
205
206			asort($tmp);
207
208			return array_unique($tmp);
209			}
210			}
211

codysnider / tt-rss

FeedItem_Common::get_enclosures() C last analyzed 2019-12-23 07:25 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

FeedItem_Common::get_enclosures() C
last analyzed 2019-12-23 07:25 UTC