#194

pending completion

Build # #194

Build Type

push

github-ci

Committed by

web-flow

Commit Message

Merge pull request #149 from jesperancinha/migration-to-kotlin

Migration to kotlin

Run Details

333 of 333 new or added lines in 13 files covered. (100.0%)

274 of 333 relevant lines covered (82.28%)

8.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.74

/markdowner-core/src/main/kotlin/org/jesperancinha/parser/markdowner/badges/parser/BadgeParser.kt

package org.jesperancinha.parser.markdowner.badges.parser

import com.fasterxml.jackson.databind.ObjectMapper
import org.jesperancinha.parser.markdowner.badges.model.*
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import java.io.IOException
import java.util.*
import java.util.regex.Pattern
import kotlin.system.exitProcess

class BadgeParser {

    companion object{
        private const val GENERIC_REGEX = "a-zA-Z0-9\\/\\.\\]\\?\\=\\-\\&\\%%\\;\\_\\#\\:\\@\\\"\\ "
        private const val EMOJI_REGEX = ".{0,4}"
        const val FULL_REGEX = GENERIC_REGEX + EMOJI_REGEX
        private const val BADGE_REGEX =
            "(\\[!\\[%s]\\(http[s]*:\\/\\/%s[$GENERIC_REGEX]*$EMOJI_REGEX[$GENERIC_REGEX]*\\)]\\((http[s]*:\\/\\/)*[$GENERIC_REGEX]*\\))"
        private val NOT_ACCEPTED_REGEX = Pattern.compile("color=(?!(informational)).")
        private val objectMapper = ObjectMapper()
        private val logger: Logger = LoggerFactory.getLogger(BadgeParser::class.java)

        private val badgeTypes = parseBadgeTypes()
        private fun parseBadgeTypes(): Map<String, BadgeType> = try {
            objectMapper.readValue(
                BadgeParser::class.java.getResourceAsStream("/jeorg.badges.types.json"),
                Array<BadgeType>::class.java
            ).associateBy { it.type }
        } catch (e: IOException) {
            logger.error("Error!", e)
            exitProcess(1)
        }

        private val badgeSettingGroups by lazy { parseSettings() }

        fun parse(readmeText: String): Map<BadgeType, BadgeGroup> = badgeSettingGroups.values
                .filterNotNull().associate { badgeSettingGroup ->
                    val allBadges = badgeSettingGroup.badgeSettingList.associate { badgePattern ->
                        badgePattern.pattern to run {
                            val matcher = badgePattern.pattern.matcher(readmeText)
                            if (matcher.find()) {
                                val badgeText = matcher.group(0)
                                val matcher1 = NOT_ACCEPTED_REGEX.matcher(badgeText)
                                val linkPrefix = badgePattern.linkPrefix
                                if (matcher1.find() || linkPrefix != null && !badgeText.contains(linkPrefix)) {
                                    null
                                } else {
                                    Badge(
                                        badgeText = badgeText,
                                        title = badgePattern.title
                                    )
                                }
                            } else {
                                null
                            }
                        }
                    }
                    badgeSettingGroup.badgeType to BadgeGroup(
                        badgeType = badgeSettingGroup.badgeType,
                        badgeHashMap = allBadges
                    )
                }


        fun parseSettings(): Map<BadgeType, BadgeSettingGroup?> =
            badgeTypes.values.associateWith { badgeType ->
                try {
                    val badgeSettingList = objectMapper.readValue(
                        BadgeParser::class.java.getResourceAsStream("/" + badgeType.badgeFile),
                        Array<BadgeSetting>::class.java
                    )
                    BadgeSettingGroup(
                        badgeType = badgeType,
                        badgeSettingList = badgeSettingList.map { badgeSetting ->
                            BadgePattern(
                                title = badgeSetting.title,
                                pattern = Pattern.compile(
                                    String.format(
                                        BADGE_REGEX,
                                        badgeSetting.badge,
                                        badgeSetting.codePrefix
                                            .replace(".", "\\.")
                                            .replace("/", "\\/")
                                    )
                                ),
                                linkPrefix = badgeSetting.linkPrefix
                            )
                        }
                    )
                } catch (e: IOException) {
                    logger.error("Error", e)
                    null
                }
            }

    }
}

1	package org.jesperancinha.parser.markdowner.badges.parser
2
3	import com.fasterxml.jackson.databind.ObjectMapper
4	import org.jesperancinha.parser.markdowner.badges.model.*
5	import org.slf4j.Logger
6	import org.slf4j.LoggerFactory
7	import java.io.IOException
8	import java.util.*
9	import java.util.regex.Pattern
10	import kotlin.system.exitProcess
11
12	class BadgeParser {	×
13
14	companion object{
15	private const val GENERIC_REGEX = "a-zA-Z0-9\\/\\.\\]\\?\\=\\-\\&\\%%\\;\\_\\#\\:\\@\\\"\\ "
16	private const val EMOJI_REGEX = ".{0,4}"
17	const val FULL_REGEX = GENERIC_REGEX + EMOJI_REGEX
18	private const val BADGE_REGEX =
19	"(\\[!\\[%s]\\(http[s]:\\/\\/%s[$GENERIC_REGEX]$EMOJI_REGEX[$GENERIC_REGEX]\\)]\\((http[s]:\\/\\/)[$GENERIC_REGEX]\\))"
20	private val NOT_ACCEPTED_REGEX = Pattern.compile("color=(?!(informational)).")	6✔
21	private val objectMapper = ObjectMapper()	8✔
22	private val logger: Logger = LoggerFactory.getLogger(BadgeParser::class.java)	12✔
23
24	private val badgeTypes = parseBadgeTypes()	6✔
25	private fun parseBadgeTypes(): Map<String, BadgeType> = try {	2✔
26	objectMapper.readValue(	16✔
27	BadgeParser::class.java.getResourceAsStream("/jeorg.badges.types.json"),	6✔
28	Array<BadgeType>::class.java
29	).associateBy { it.type }	14✔
30	} catch (e: IOException) {	×
31	logger.error("Error!", e)	×
32	exitProcess(1)	2✔
33	}	2✔
34
35	private val badgeSettingGroups by lazy { parseSettings() }	28✔
36
37	fun parse(readmeText: String): Map<BadgeType, BadgeGroup> = badgeSettingGroups.values	8✔
38	.filterNotNull().associate { badgeSettingGroup ->	10✔
39	val allBadges = badgeSettingGroup.badgeSettingList.associate { badgePattern ->	14✔
40	badgePattern.pattern to run {	18✔
41	val matcher = badgePattern.pattern.matcher(readmeText)	12✔
42	if (matcher.find()) {	12✔
43	val badgeText = matcher.group(0)	8✔
44	val matcher1 = NOT_ACCEPTED_REGEX.matcher(badgeText)	10✔
45	val linkPrefix = badgePattern.linkPrefix	6✔
46	if (matcher1.find() \|\| linkPrefix != null && !badgeText.contains(linkPrefix)) {	10✔
47	null	4✔
48	} else {
49	Badge(	8✔
50	badgeText = badgeText,	2✔
51	title = badgePattern.title	8✔
52	)
53	}
54	} else {
55	null	2✔
56	}
57	}
58	}
59	badgeSettingGroup.badgeType to BadgeGroup(	12✔
60	badgeType = badgeSettingGroup.badgeType,	4✔
61	badgeHashMap = allBadges	2✔
62	)
63	}	2✔
64
65
66	fun parseSettings(): Map<BadgeType, BadgeSettingGroup?> =
67	badgeTypes.values.associateWith { badgeType ->	12✔
68	try {	12✔
69	val badgeSettingList = objectMapper.readValue(	10✔
70	BadgeParser::class.java.getResourceAsStream("/" + badgeType.badgeFile),	22✔
71	Array<BadgeSetting>::class.java
72	)
73	BadgeSettingGroup(	18✔
74	badgeType = badgeType,	2✔
75	badgeSettingList = badgeSettingList.map { badgeSetting ->	16✔
76	BadgePattern(	10✔
77	title = badgeSetting.title,	4✔
78	pattern = Pattern.compile(	8✔
79	String.format(	22✔
80	BADGE_REGEX,	4✔
81	badgeSetting.badge,	24✔
82	badgeSetting.codePrefix	4✔
83	.replace(".", "\\.")	12✔
84	.replace("/", "\\/")	14✔
85	)
86	),
87	linkPrefix = badgeSetting.linkPrefix	4✔
88	)
89	}
90	)
91	} catch (e: IOException) {	×
92	logger.error("Error", e)	×
93	null	2✔
94	}
95	}	2✔
96
97	}
98	}

jesperancinha / markdowner / #194

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous