Scala JIRA

Scala JIRA ============ JIRA, an issue tracker can do a bunch of data import/export and operations - via CSV - via REST However neither of them responses 1000 items per request. So REST is better for a lot of data or complex operations. Atlassian provide Java library for JIRA REST, [JIRA REST Java Client (JRJC)](https://ecosystem.atlassian.net/wiki/display/JRJC/Home) When you program for JIRA REST, you would use it but I don't feel like using Java in this programming era. Thus I created a scaffold for JIRA REST with Scala. Why I create it and show here is there is no specific documentation for the latest JRJC somehow. - classes and their structures are changed. - its sbt configuration (Maven dependencies) not written anywhere. Let's show my scaffold. Here is dependencies in build.sbt. ```scala libraryDependencies += "com.atlassian.jira" % "jira-rest-java-client-api" % "3.0.0" libraryDependencies += "com.atlassian.jira" % "jira-rest-java-client-core" % "3.0.0" resolvers += "spring-milestones" at "http://repo.spring.io/libs-milestone/" ``` Here is my sample app, which needs more dependencies than the above. ```scala import java.net.URI import com.atlassian.jira.rest.client.internal.async.AsynchronousJiraRestClientFactory import org.joda.time.DateTime import org.joda.time.format._ import scala.collection.JavaConverters._ /** * Created on 2015/12/02. */ object Auth { def main(args: Array[String]) { val restClientFactory = new AsynchronousJiraRestClientFactory() // http://host:port/context/rest/api-name/api-version/resource-name import com.typesafe.config.ConfigFactory val conf = ConfigFactory.load("account.conf") //val JIRA_BASE_URL = "http://[team name].atlassian.net/plugins/servlet/oauth/request-token" val jiraBaseURL = conf.getString("baseurl") // JIRA_BASE_URL + "/plugins/servlet/oauth/request-token" val uri = new URI(jiraBaseURL) val username = conf.getString("username") val password = conf.getString("password") val client = restClientFactory.createWithBasicHttpAuthentication(uri, username, password) // Invoke the JRJC Client val promise = client.getUserClient().getUser(username) val user = promise.claim() client.getProjectClient().getAllProjects().claim().iterator().asScala.map(project => { println(project.getKey() + ": " + project.getName()) }) val dateTime = DateTime.now() val dateString = DateTimeFormat.forPattern("yyyy-MM-dd").print(dateTime) println("dateString=" + dateString) // up to 1000 items even if you specify more. val maxResults = 10 val searchJqlPromise = client.getSearchClient().searchJql(s"due=$dateString ORDER BY assignee", maxResults, null, null) searchJqlPromise.claim().getIssues.asScala.map(issue => { println(issue.getKey + ": " + issue.getSummary) }) // Print the result println(String.format("Your admin user's email address is: %s\r\n", user.getEmailAddress())); // Done println("Example complete. Now exiting."); System.exit(0); } } ``` The whole source codes are [HERE](https://github.com/lamusique/ScalaJIRA).

Processing with Scala

Processing with Scala ====================== The Processing program language is based on Java. Now while we are in the functional mathematical programming era, it's troublesome to write with Java, which has legacy computer grammar and syntax, e.g. you ought to write imperative `;` at the end of the line. Therefore I reify Processing with Scala, which runs on the JVM. It is similar strategy of P5.js, which runs as pure JavaScript. I created a kind of the framework for Processing with Scala. > https://github.com/lamusique/ScalaProcessing It became easier to import Processing jars since Processing libraries are in the Maven Repository and I imported them on sbt. Well let's get started and here is an example. I take an example from the official Processing Examples https://processing.org/examples/bouncybubbles.html and port it to Scala. ```scala package com.nekopiano.scala.processing.sandbox.sample import com.nekopiano.scala.processing.ScalaPApplet import processing.core.PApplet class BouncyBubbles extends ScalaPApplet { import BouncyBubbles._ val balls:Set[Ball] = { // in parallel val localBalls = (0 to numBalls).par.map(i => { new Ball(random(width), random(height), random(30, 70), i) }).seq.toSet localBalls.foreach(_.others = localBalls) localBalls } override def settings(): Unit = { size(640, 360) } override def setup() { noStroke() fill(255, 204) } override def draw() { background(0) balls.foreach(ball => { ball.collide() ball.move() ball.display() }) } } object BouncyBubbles { // Constants val numBalls = 12 val spring = 0.05f val gravity = 0.03f val friction = -0.9f // ==== booting process val BOOTING_CLASS_NAME = this.getClass.getName.dropRight(1) def main(args: Array[String]) { // This specifies the class to be instantiated. val appletArgs = Array(BOOTING_CLASS_NAME) if (args != null) { PApplet.main(PApplet.concat(appletArgs, args)) } else { PApplet.main(appletArgs) } } } class Ball(var x:Float, var y:Float, val diameter:Float, val id:Int)(implicit val sp5: ScalaPApplet) { import sp5._ import com.nekopiano.scala.processing.Angles._ import BouncyBubbles._ var others: Set[Ball] = Set.empty[Ball] var vx = 0f var vy = 0f def collide() { others.foreach(ball => { val dx = ball.x - x val dy = ball.y - y val distance = sqrt(dx*dx + dy*dy) val minDist = ball.diameter/2 + this.diameter/2 if (distance < minDist) { val angle = atan2(dy, dx) val targetX = x + cos(angle) * minDist val targetY = y + sin(angle) * minDist val ax = (targetX - ball.x) * spring val ay = (targetY - ball.y) * spring vx -= ax vy -= ay ball.vx += ax ball.vy += ay } }) } def move() { vy += gravity x += vx y += vy if (x + diameter/2 > width) { x = width - diameter/2 vx *= friction } else if (x - diameter/2 < 0) { x = diameter/2 vx *= friction } if (y + diameter/2 > height) { y = height - diameter/2 vy *= friction } else if (y - diameter/2 < 0) { y = diameter/2 vy *= friction } } def display() { ellipse(x, y, diameter, diameter) } } ``` Hmm, it doesn't make so much difference yet... I may have taken not good example. The framework of Processing with Scala hasn't yet ported from all the classes of the original Processing, e.g. all the methods of `PApplet`, so it's work in progress. The concurrent processes with Scala make errors because drawing processes (line(), box(), etc.) are done by GPU. Scala has to stop the concurrency before GPU drawing. I hope I will create an editor of Processing for Scala, which makes easily you write codes and test them. The Scala editor, SPD we know but the project has been suspended for 6 years... https://github.com/n8han/spde-examples If you are Scalaist, you should play Processing with Scala. You can use https://github.com/lamusique/ScalaProcessing as a template and you will understand Processing deeper.

Fibonacci Number and their Factors

Here are Fibonacci numbers and their factors I calculated with Scala. ``` fib(1) = 0 = 0 fib(2) = 1 = 1 fib(3) = 1 = 1 fib(4) = 2 = 2 fib(5) = 3 = 3 fib(6) = 5 = 5 fib(7) = 8 = 2 * 2 * 2 fib(8) = 13 = 13 fib(9) = 21 = 7 * 3 fib(10) = 34 = 17 * 2 fib(11) = 55 = 11 * 5 fib(12) = 89 = 89 fib(13) = 144 = 3 * 3 * 2 * 2 * 2 * 2 fib(14) = 233 = 233 fib(15) = 377 = 29 * 13 fib(16) = 610 = 61 * 5 * 2 fib(17) = 987 = 47 * 7 * 3 fib(18) = 1597 = 1597 fib(19) = 2584 = 19 * 17 * 2 * 2 * 2 fib(20) = 4181 = 113 * 37 fib(21) = 6765 = 41 * 11 * 5 * 3 fib(22) = 10946 = 421 * 13 * 2 fib(23) = 17711 = 199 * 89 fib(24) = 28657 = 28657 fib(25) = 46368 = 23 * 7 * 3 * 3 * 2 * 2 * 2 * 2 * 2 fib(26) = 75025 = 3001 * 5 * 5 fib(27) = 121393 = 521 * 233 fib(28) = 196418 = 109 * 53 * 17 * 2 fib(29) = 317811 = 281 * 29 * 13 * 3 fib(30) = 514229 = 514229 fib(31) = 832040 = 61 * 31 * 11 * 5 * 2 * 2 * 2 fib(32) = 1346269 = 2417 * 557 fib(33) = 2178309 = 2207 * 47 * 7 * 3 fib(34) = 3524578 = 19801 * 89 * 2 fib(35) = 5702887 = 3571 * 1597 fib(36) = 9227465 = 141961 * 13 * 5 fib(37) = 14930352 = 107 * 19 * 17 * 3 * 3 * 3 * 2 * 2 * 2 * 2 fib(38) = 24157817 = 2221 * 149 * 73 fib(39) = 39088169 = 9349 * 113 * 37 fib(40) = 63245986 = 135721 * 233 * 2 fib(41) = 102334155 = 2161 * 41 * 11 * 7 * 5 * 3 fib(42) = 165580141 = 59369 * 2789 fib(43) = 267914296 = 421 * 211 * 29 * 13 * 2 * 2 * 2 fib(44) = 433494437 = 433494437 fib(45) = 701408733 = 307 * 199 * 89 * 43 * 3 fib(46) = 1134903170 = 109441 * 61 * 17 * 5 * 2 fib(47) = 1836311903 = 28657 * 461 * 139 fib(48) = 2971215073 = 2971215073 fib(49) = 4807526976 = 1103 * 47 * 23 * 7 * 3 * 3 * 2 * 2 * 2 * 2 * 2 * 2 fib(50) = 7778742049 = 6168709 * 97 * 13 fib(51) = 12586269025 = 3001 * 151 * 101 * 11 * 5 * 5 fib(52) = 20365011074 = 6376021 * 1597 * 2 fib(53) = 32951280099 = 90481 * 521 * 233 * 3 fib(54) = 53316291173 = 55945741 * 953 fib(55) = 86267571272 = 5779 * 109 * 53 * 19 * 17 * 2 * 2 * 2 fib(56) = 139583862445 = 474541 * 661 * 89 * 5 fib(57) = 225851433717 = 14503 * 281 * 29 * 13 * 7 * 7 * 3 fib(58) = 365435296162 = 54833 * 797 * 113 * 37 * 2 fib(59) = 591286729879 = 514229 * 19489 * 59 fib(60) = 956722026041 = 2710260697 * 353 fib(61) = 1548008755920 = 2521 * 61 * 41 * 31 * 11 * 5 * 3 * 3 * 2 * 2 * 2 * 2 fib(62) = 2504730781961 = 555003497 * 4513 fib(63) = 4052739537881 = 3010349 * 2417 * 557 fib(64) = 6557470319842 = 35239681 * 421 * 17 * 13 * 2 ```

Functional Patterns - Pair Reducing

How to manipulate each pair of a collection. grouped ======= If you want to merge each two elements of a collection, like ```` 1 2 3 4 5 | v 1 + 2 3 + 4 5 ``` Going on with Scala for example use Solution I (better) 1. `grouped` 1. `map` ```scala val grouped = collection.grouped(2).toSeq val pairReduced = grouped.map(pair => {pair(0) + pair(1)}) pairReduced foreach println ``` Solution II 1. `zipWithIndex` 1. `groupBy` 1. `zip` 1. `map` ```scala val divided = collection.zipWithIndex.groupBy{case (e, i) => {(i + 1)%2}} val zipped = divided(0) zip divided(1) val pairs = zipped.map(pair => { pair._1._1 + pair._2._1 }) ```

Functional Patterns - zip

How to manipulate each pair of two collections. zip === Let's say two lists you have and you want to add each pair of them, like ``` 1 + 6 2 + 7 3 + 8 4 + 9 5 + 10 ``` Going on with Scala ```scala List a 1 2 3 4 5 ``` ```scala List b 6 7 8 9 10 ``` ```scala val c = a zip b ``` ```scala List c (1, 6) (2, 7) (3, 8) (4, 9) (5, 10) ``` ```scala val results = c map {case (a, b) => {a + b}} ```

difference between method and function in Scala

The official ScalaReference says Method types do not exist as types of values. [cont.] #scala #scalajp

— Rhizome (@rhizome1976) August 19, 2013

If a method name is used as a value, its type is implicitly converted to a corresponding function type (§6.26). #scala #scalajp

— Rhizome (@rhizome1976) August 19, 2013

How to create XML models in Scala? - scalaxb

How to create XML models in Scala?

Currently the way to create XML models in Scala (like JAXB) is scalaxb, cf. https://github.com/eed3si9n/scalaxb, http://scalaxb.org/.

Among several ways, to run scalaxb sbt-scalaxb is the simplest one to do so but I believe there is no full covered procedure for that so I write it here :)

Let's say we use scalaxb 1.3.0.

1. Set up sbt files.

To call scalaxb from sbt 0.13.x, put this in your project/scalaxb.sbt:

resolvers += Resolver.sonatypeRepo("public")

addSbtPlugin("org.scalaxb" % "sbt-scalaxb" % "1.3.0")

and this in scalaxb.sbt:

scalaxbSettings
// Write your own package
packageName in scalaxb in Compile := "com.blogger.xml"

sourceGenerators in Compile <+= scalaxb in Compile
// The version of Dispatch, which is an HTTP access library and in some cases scalaxb depends on.
dispatchVersion in scalaxb in Compile := "0.11.2"

Note: As of Scala 2.11, you need to write the parsing library dependency separately, like

libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.4"

2. Put XSD files into src/main/xsd.

3. Run $ sbt scalaxb on your project.

4. You'll see generated sources in target/scala-2.11/src_managed/main/sbt-scalaxb.

That's it.

When a Scalaist has to use Java

Use Guava, the library by Google!

https://code.google.com/p/guava-libraries/wiki/GuavaExplained

That enables you to write in functional style.