Merge branch '#3_repository-search'

Conflicts:
	src/main/scala/app/UserManagementController.scala
	src/main/scala/service/IssuesService.scala
	src/main/twirl/issues/issue.scala.html

src/main/scala/service/IssuesService.scala

@@ -6,6 +6,8 @@ import scala.slick.jdbc.{StaticQuery => Q}
 import Q.interpolation
 
 import model._
+import util.Implicits._
+import util.StringUtil
 
 trait IssuesService {
   import IssuesService._
@@ -235,6 +237,52 @@ trait IssuesService {
       }
       .update (closed, currentDate)
 
+  /**
+   * Search issues by keyword.
+   *
+   * @param owner the repository owner
+   * @param repository the repository name
+   * @param query the keywords separated by whitespace.
+   * @return issues with comment count and matched content of issue or comment
+   */
+  def searchIssuesByKeyword(owner: String, repository: String, query: String): List[(Issue, Int, String)] = {
+    import scala.slick.driver.H2Driver.likeEncode
+    val keywords = StringUtil.splitWords(query.toLowerCase)
+
+    // Search Issue
+    val issues = Query(Issues).filter { t =>
+      keywords.map { keyword =>
+        (t.title.toLowerCase like (s"%${likeEncode(keyword)}%", '^')) || (t.content.toLowerCase like (s"%${likeEncode(keyword)}%", '^'))
+      } .reduceLeft(_ && _)
+    }.map { t => (t, 0, t.content) }
+
+    // Search IssueComment
+    val comments = Query(IssueComments).innerJoin(Issues).on { case (t1, t2) =>
+      t1.byIssue(t2.userName, t2.repositoryName, t2.issueId)
+    }.filter { case (t1, t2) =>
+      keywords.map { query =>
+        t1.content.toLowerCase like (s"%${likeEncode(query)}%", '^')
+      }.reduceLeft(_ && _)
+    }.map { case (t1, t2) => (t2, t1.commentId, t1.content) }
+
+    // TODO Excludes some actions which should be ignored.
+    def getCommentCount(issue: Issue): Int = {
+      Query(IssueComments)
+        .filter(_.byIssue(issue.userName, issue.repositoryName, issue.issueId))
+        .map(_.issueId)
+        .list.length
+    }
+
+    issues.union(comments).sortBy { case (issue, commentId, _) =>
+      issue.issueId ~ commentId
+    }.list.splitWith { case ((issue1, _, _), (issue2, _, _)) =>
+      issue1.issueId == issue2.issueId
+    }.map { result =>
+      val (issue, _, content) = result.head
+      (issue, getCommentCount(issue) , content)
+    }.toList
+  }
+
 }
 
 object IssuesService {
@@ -281,4 +329,5 @@ object IssuesService {
         param(request, "sort",      Seq("created", "comments", "updated")).getOrElse("created"),
         param(request, "direction", Seq("asc", "desc")).getOrElse("desc"))
   }
+
 }

src/main/scala/service/RepositorySearchService.scala

@@ -0,0 +1,121 @@
+package service
+
+import model.Issue
+import util.{FileUtil, StringUtil, JGitUtil}
+import util.Directory._
+import model.Issue
+import org.eclipse.jgit.revwalk.RevWalk
+import org.eclipse.jgit.treewalk.TreeWalk
+import scala.collection.mutable.ListBuffer
+import org.eclipse.jgit.lib.FileMode
+import org.eclipse.jgit.api.Git
+
+trait RepositorySearchService { self: IssuesService =>
+  import RepositorySearchService._
+
+  def countIssues(owner: String, repository: String, query: String): Int =
+    searchIssuesByKeyword(owner, repository, query).length
+
+  def searchIssues(owner: String, repository: String, query: String): List[IssueSearchResult] =
+    searchIssuesByKeyword(owner, repository, query).map { case (issue, commentCount, content) =>
+      IssueSearchResult(
+        issue.issueId,
+        issue.title,
+        issue.openedUserName,
+        issue.registeredDate,
+        commentCount,
+        getHighlightText(content, query)._1)
+    }
+
+  def countFiles(owner: String, repository: String, query: String): Int =
+    JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+      searchRepositoryFiles(git, query).length
+    }
+
+  def searchFiles(owner: String, repository: String, query: String): List[FileSearchResult] =
+    JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+      val files = searchRepositoryFiles(git, query)
+      val commits = JGitUtil.getLatestCommitFromPaths(git, files.toList.map(_._1), "HEAD")
+      files.map { case (path, text) =>
+        val (highlightText, lineNumber)  = getHighlightText(text, query)
+        FileSearchResult(
+          path,
+          commits(path).getCommitterIdent.getWhen,
+          highlightText,
+          lineNumber)
+      }
+    }
+
+  private def searchRepositoryFiles(git: Git, query: String): List[(String, String)] = {
+    val revWalk   = new RevWalk(git.getRepository)
+    val objectId  = git.getRepository.resolve("HEAD")
+    val revCommit = revWalk.parseCommit(objectId)
+    val treeWalk  = new TreeWalk(git.getRepository)
+    treeWalk.setRecursive(true)
+    treeWalk.addTree(revCommit.getTree)
+
+    val keywords = StringUtil.splitWords(query.toLowerCase)
+    val list = new ListBuffer[(String, String)]
+
+    while (treeWalk.next()) {
+      if(treeWalk.getFileMode(0) != FileMode.TREE){
+        JGitUtil.getContent(git, treeWalk.getObjectId(0), false).foreach { bytes =>
+          if(FileUtil.isText(bytes)){
+            val text      = new String(bytes, "UTF-8")
+            val lowerText = text.toLowerCase
+            val indices   = keywords.map(lowerText.indexOf _)
+            if(!indices.exists(_ < 0)){
+              list.append((treeWalk.getPathString, text))
+            }
+          }
+        }
+      }
+    }
+    treeWalk.release
+    revWalk.release
+
+    list.toList
+  }
+
+}
+
+object RepositorySearchService {
+
+  val CodeLimit  = 10
+  val IssueLimit = 10
+
+  def getHighlightText(content: String, query: String): (String, Int) = {
+    val keywords  = StringUtil.splitWords(query.toLowerCase)
+    val lowerText = content.toLowerCase
+    val indices   = keywords.map(lowerText.indexOf _)
+
+    if(!indices.exists(_ < 0)){
+      val lineNumber = content.substring(0, indices.min).split("\n").size - 1
+      val highlightText = StringUtil.escapeHtml(content.split("\n").drop(lineNumber).take(5).mkString("\n"))
+        .replaceAll("(?i)(" + keywords.map("\\Q" + _ + "\\E").mkString("|") +  ")",
+        "<span style=\"background-color: #ffff88;;\">$1</span>")
+      (highlightText, lineNumber + 1)
+    } else {
+      (content.split("\n").take(5).mkString("\n"), 1)
+    }
+  }
+
+  case class SearchResult(
+    files : List[(String, String)],
+    issues: List[(Issue, Int, String)])
+
+  case class IssueSearchResult(
+    issueId: Int,
+    title: String,
+    openedUserName: String,
+    registeredDate: java.util.Date,
+    commentCount: Int,
+    highlightText: String)
+
+  case class FileSearchResult(
+     path: String,
+     lastModified: java.util.Date,
+     highlightText: String,
+     highlightLineNumber: Int)
+
+}

src/main/scala/service/WikiService.scala

@@ -6,7 +6,6 @@ import org.eclipse.jgit.api.Git
 import org.apache.commons.io.FileUtils
 import util.JGitUtil.DiffInfo
 import util.{Directory, JGitUtil}
-import org.eclipse.jgit.lib.RepositoryBuilder
 import org.eclipse.jgit.treewalk.CanonicalTreeParser
 import java.util.concurrent.ConcurrentHashMap