Added vendor lock on depsHEADmaster

1 files changed, 202 insertions, 0 deletions

diff --git a/vendor/github.com/DavidBelicza/TextRank/v2/rank/sorting.go b/vendor/github.com/DavidBelicza/TextRank/v2/rank/sorting.go
new file mode 100644
index 0000000..6d00a97
--- /dev/null
+++ b/vendor/github.com/DavidBelicza/TextRank/v2/rank/sorting.go
@@ -0,0 +1,202 @@
+package rank
+
+import (
+        "sort"
+)
+
+// Phrase struct contains a single phrase and its data.
+//
+// LeftID is the ID of the word 1.
+//
+// RightID is the ID of the word 2.
+//
+// Left is the token of the word 1.
+//
+// Right is the token of the word 2.
+//
+// Weight is between 0.00 and 1.00.
+//
+// Qty is the occurrence of the phrase.
+type Phrase struct {
+        LeftID  int
+        RightID int
+        Left    string
+        Right   string
+        Weight  float32
+        Qty     int
+}
+
+// FindPhrases function has wrapper textrank.FindPhrases. Use the wrapper
+// instead.
+func FindPhrases(ranks *Rank) []Phrase {
+        var phrases []Phrase
+
+        for x, xMap := range ranks.Relation.Node {
+                for y := range xMap {
+                        phrases = append(phrases, Phrase{
+                                ranks.Words[x].ID,
+                                ranks.Words[y].ID,
+                                ranks.Words[x].Token,
+                                ranks.Words[y].Token,
+                                ranks.Relation.Node[x][y].Weight,
+                                ranks.Relation.Node[x][y].Qty,
+                        })
+                }
+        }
+
+        sort.Slice(phrases, func(i, j int) bool {
+                return phrases[i].Weight > phrases[j].Weight
+        })
+
+        return phrases
+}
+
+// SingleWord struct contains a single word and its data.
+//
+// ID of the word.
+//
+// Word itself, the token.
+//
+// Weight of the word between 0.00 and 1.00.
+//
+// Quantity of the word.
+type SingleWord struct {
+        ID     int
+        Word   string
+        Weight float32
+        Qty    int
+}
+
+// FindSingleWords function has wrapper textrank.FindSingleWords. Use the
+// wrapper instead.
+func FindSingleWords(ranks *Rank) []SingleWord {
+        var singleWords []SingleWord
+
+        for _, word := range ranks.Words {
+                singleWords = append(singleWords, SingleWord{
+                        word.ID,
+                        word.Token,
+                        word.Weight,
+                        word.Qty,
+                })
+        }
+
+        sort.Slice(singleWords, func(i, j int) bool {
+                return singleWords[i].Weight > singleWords[j].Weight
+        })
+
+        return singleWords
+}
+
+// Sentence struct contains a single sentence and its data.
+type Sentence struct {
+        ID    int
+        Value string
+}
+
+// ByQty filter by occurrence of word.
+const ByQty = 0
+
+// ByRelation filter by phrase weight.
+const ByRelation = 1
+
+// FindSentences function has wrappers textrank.FindSentencesByRelationWeight
+// and textrank.FindSentencesByWordQtyWeight. Use the wrappers instead.
+func FindSentences(ranks *Rank, kind int, limit int) []Sentence {
+        var sentences []Sentence
+
+        cache := make(map[int]bool)
+
+        collect := func(sentenceIDs []int) bool {
+                for _, id := range sentenceIDs {
+                        if len(sentences) >= limit {
+                                return true
+                        }
+
+                        if !cache[id] {
+                                sentences = append(sentences, Sentence{id, ranks.SentenceMap[id]})
+                                cache[id] = true
+                        }
+                }
+
+                return false
+        }
+
+        if kind == ByQty {
+                singleWords := FindSingleWords(ranks)
+
+                for _, singleWord := range singleWords {
+                        sentenceIDs := ranks.Words[singleWord.ID].SentenceIDs
+
+                        if collect(sentenceIDs) {
+                                return sentences
+                        }
+                }
+        } else if kind == ByRelation {
+                phrases := FindPhrases(ranks)
+
+                for _, phrase := range phrases {
+                        sentenceIDs := ranks.Relation.Node[phrase.LeftID][phrase.RightID].SentenceIDs
+
+                        if collect(sentenceIDs) {
+                                return sentences
+                        }
+                }
+        }
+
+        return sentences
+}
+
+// FindSentencesByPhrases function has wrapper
+// textrank.FindSentencesByPhraseChain. Use the wrapper instead.
+func FindSentencesByPhrases(ranks *Rank, words []string) []Sentence {
+        var sentences []Sentence
+
+        reqMatch := len(words) - 1
+        sentenceIDs := make(map[int]int)
+
+        for _, i := range words {
+                for _, j := range words {
+                        x := ranks.WordValID[i]
+                        y := ranks.WordValID[j]
+
+                        if _, ok := ranks.Relation.Node[x][y]; ok {
+                                curSentenceIDs := ranks.Relation.Node[x][y].SentenceIDs
+
+                                for _, id := range curSentenceIDs {
+                                        if _, ok := sentenceIDs[id]; ok {
+                                                sentenceIDs[id]++
+                                        } else {
+                                                sentenceIDs[id] = 1
+                                        }
+                                }
+                        }
+                }
+        }
+
+        for sentenceID, v := range sentenceIDs {
+                if v >= reqMatch {
+                        sentences = append(sentences, Sentence{sentenceID, ranks.SentenceMap[sentenceID]})
+                }
+        }
+
+        sort.Slice(sentences, func(i, j int) bool {
+                return sentences[i].ID < sentences[j].ID
+        })
+
+        return sentences
+}
+
+// FindSentencesFrom function has wrapper textrank.FindSentencesFrom. Use the
+// wrapper instead.
+func FindSentencesFrom(ranks *Rank, id int, limit int) []Sentence {
+        var sentences []Sentence
+
+        limit = id + limit - 1
+
+        for i := id; i <= limit; i++ {
+                sentences = append(sentences, Sentence{i, ranks.SentenceMap[i]})
+        }
+
+        return sentences
+}