Merge remote-tracking branch 'origin/develop'

jpsacha · jpsacha · commit 4cac88f0bbcb · 2018-12-12T18:44:21.000-05:00
diff --git a/README.md b/README.md
@@ -27,12 +27,7 @@ Add `sbt-imagej` as a dependency in `project/imagej.sbt`:
 addSbtPlugin("net.sf.ij-plugins" % "sbt-imagej" % "2.0.1")
 ```
 
-To use `sbt-imagej` you need to enable it in your project configuration,
-if you're using `build.sbt` add this:
-
-```scala
-enablePlugins(SbtImageJ)
-```
+Once added to the project the plugin will be enabled by default.
 
 Now you'll have a new `ijRun` task which will compile your project,
 pack your class files and resources in a jar, copy that jar and dependencies to local
@@ -45,7 +40,6 @@ There is also a task that only copies the jar and dependencies to to the plugins
     > ijPrepareRun
 
 It is useful if you want to have your own run configuration, for instance executed by your IDE.
-Look in the `example` directory to see how it can be used in IntelliJ IDEA or Eclipse.
 
 ### Configuration
 
@@ -66,10 +60,8 @@ Consider example settings:
 
 ```scala
 ijRuntimeSubDir := "sandbox"
-
 ijPluginsSubDir := "my-plugin"
-
-ijExclusions += """some\.jar"""
+ijExclusions    += """some\.jar"""
 ```
 
 This will set ImageJ runtime directory to `sandbox` and directory where your plugins will be
@@ -83,7 +75,7 @@ where all jars will be copied. `ijPluginsDir` is intended to be read-only. It ca
 for instance, in `cleanFiles += ijPluginsDir.value`. By default, it is computed from
 `ijPluginsSubDir` and `ijRuntimeSubDir`. You should not reassign it.
 
-### Multi-Module Projects###
+### Multi-Module Projects
 
 If you are using a multi-module projects and would like to include dependent project jars in the plugins directory
 you need to take extra steps. When a SBT creates a classpath from dependent projects it exports a directory containing its
@@ -102,8 +94,8 @@ You need to add `exportsJars := true` to every dependent projects in your build.
 Example Project
 ---------------
 
-You can find example project in sub-directory [example].
-It contains SBT setup, two ImageJ plugins, and a workaround to run SBT tasks from IDEA and Eclipse.
+You can find example project in sub-directory [example]. 
+It contains a simple project with with two ImageJ plugins.
 
 
 Tips and Tricks
@@ -137,39 +129,52 @@ ijPrepareRun := ijPrepareRun.value ++ {
 }
 ```
 
-### Running SBT tasks at part of IDEA or Eclipse build ###
-
-[IntelliJ IDEA](https://www.jetbrains.com/idea/) can load SBT projects using its Scala plugin.
-To execute SBT tasks before run/debug you will additionally need SBT plugin.
-You can setup your run configuration as described in [example/README.md](example).
-
-Eclipse does noy currently support SBT tasks, but you can execute them indirectly be calling them from Ant.
-
-```xml
-<target name="sbt-imagej-prepare-run"
-        description="Run SBT task 'prepareRun' that prepares ImageJ plugins directory">
-    <property environment="env"/>
-    <fail unless="env.SBT_HOME"
-          message="SBT_HOME system variable must be defined and point to directory containing 'sbt-launch.jar'"/>
-    <property name="sbt-launch.jar" location="${env.SBT_HOME}/bin/sbt-launch.jar"/>
-
-    <java dir="${basedir}"
-          jar="${sbt-launch.jar}"
-          fork="true"
-          failonerror="true">
-        <jvmarg line="-Dfile.encoding=UTF8 -Xmx1G -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m
-                      -Djava.net.useSystemProxies=true"/>
-        <arg line="ijPrepareRun"/>
-    </java>
-</target>
-```
+### Running using SBT
+
+1. Open command prompt
+2. Change directory to one containing this project
+3. Execute command `sbt ijRun`
+
+### Running SBT tasks at part of IntelliJ IDEA build
+
+[IntelliJ IDEA](https://www.jetbrains.com/idea/), with Scala plugin, can directly load SBT projects.
+You can then execute sbt tasks to build and copy needed jars to run your plugins in ImageJ.
+
+#### Option 1: Run `ijRun` task as "Run Configuration"
+
+1. From the menu select "Run" > "Edit Configurations..."
+2. Click `+` (add new configuration) and select "sbt Task" as configuration type
+3. Give the configuration a name, say "ImageJ"
+4. Under "Tasks" type `ijRun`
+5. Make sure that working directory points to your module directory
+
+Now you have new run configuration that will build your code, package jars, and start ImageJ with your plugins.
+
+The downside of this method is that IntelliJ will not let you debug you code if you start it this way.
+
+#### Option 2: Add `ijPrepareRun` to a typical application run configuration
+
+The idea is to create a regular application run configuration and execute `sbt ijPrepareRun` to setup runtime directories:
 
-You can find complete [build.xml](example/build.xml) in the [example](example) project.
+1. From the menu select "Run" > "Edit Configurations..."
+2. Click `+` (add new configuration) and select "Application" as configuration type
+3. Give you configuration a name, say "ImageJ"
+4. In "Main class:" type `ij.ImageJ`
+5. In "Working directory:" select subdirectory "sandbox" of your module directory (or a directory you defined in `ijRuntimeSubDir`)
+6. Select relevant project module.
+7. In "Before lunch:" select `+` and then select "Run External Tool"
+8. In "External Tool" window select `+` to define how to execute `sbt ijPrepareRun`
+9. Give the external toll configuration some name.
+10. In "Program:" type `sbt`
+11. In "Arguments:" type `ijPrepareRun`
+12. In "Working directory:" select your module directory
+13. Click "OK" a couple of times to close dialogs
 
+Now you have definition of an application run configuration that will run ImageJ, before the run SBT will be called to prepare plugin jars and copy them to plugins subdirectory.
 
 License
 -------
 
-Copyright (c) 2013-2017 Jarek Sacha
+Copyright (c) 2013-2018 Jarek Sacha
 
 Published under GPLv3, see LICENSE file.
diff --git a/build.sbt b/build.sbt
@@ -1,30 +1,18 @@
 // @formatter:off
+
 sbtPlugin := true
 
 name          := "sbt-imagej"
 organization  := "net.sf.ij-plugins"
-version       := "2.0.1"
+version       := "2.0.2-SNAPSHOT"
 description   := "SBT plugin that helps create runtime directory structure for ImageJ plugin development."
 homepage      := Some(url("http://github.com/jpsacha/sbt-imagej"))
 organizationHomepage := Some(url("http://ij-plugins.sf.net"))
 startYear     := Some(2013)
 licenses      := Seq("GPLv3" -> url("http://www.gnu.org/licenses/gpl.html"))
 
-scalaVersion  := "2.10.6"
+scalaVersion  := "2.12.8"
 
 scalacOptions := Seq("-deprecation", "-unchecked")
 
-publishArtifact in(Test, packageBin) := false
-publishArtifact in(Test, packageDoc) := false
-publishArtifact in(Test, packageSrc) := false
-
 shellPrompt in ThisBuild := { state => "sbt:"+Project.extract(state).currentRef.project + "> " }
-
-publishTo := version {
-  version: String =>
-    val nexus = "https://oss.sonatype.org/"
-    if (version.contains("-SNAPSHOT"))
-      Some("snapshots" at nexus + "content/repositories/snapshots")
-    else
-      Some("releases"  at nexus + "service/local/staging/deploy/maven2")
-}.value
diff --git a/example/README.md b/example/README.md
@@ -24,47 +24,3 @@ implemented in Scala, the second in Java.
 * `example/src/main/java/effects/Vignette.java` - a plugin adding darken border to a color image.
 * `example/src/main/resources/plugins.config` - manifest that instructs ImageJ in which menu to
 install the plugins.
-
-There is also an Ant file that helps to integrate `sbt-imagej` into a build performed by an IDE
-(till they can execute SBT tasks directly). See details in the next section.
-
-* `example/build.xml` - Ant configuration that has a target to call SBT task `ijPrepareRun`
-
-Running
--------
-
-The simplest way to build and run the example is to use SBT. It also can be used from IntelliJ
-IDEA, Eclipse, and NetBeans. In all cases it assumes that you have [SBT](http://www.scala-sbt.org/) installed
-on your system.
-
-### Using SBT ###
-
-1. Open command prompt
-2. Change directory to one containing this project
-3. Execute command `sbt ijRun`
-
-### Using IntelliJ IDEA ###
-
-We assume here that you have [IntelliJ IDEA](http://www.jetbrains.com/idea/) 14 installed together
-with the Scala and SBT plugins. Scala plugin supports loading SBT projects into IDEA.
-The SBT plugin adds ability to execute SBT tasks before run/debug.
-
- 1. Start IDEA
- 1. Select "Import Project" and load the `example/build.sbt`. This will let you edit and build
-    the project.
- 1. To run ImageJ with the custom plugin you need to invoke `ijPrepareRun` tasks before running ImageJ.
- 1. Click `Run` > `Edit Configurations`
- 1. Add new application configuration, call it for instance, `ImageJ`
- 1. Set main class to `ij.ImageJ`
- 1. Set "Working directory" to `example/sandbox`
- 1. Click on "+" under "Before lunch", select "SBT", in the combo box type `ijPrepareRun`, hit Enter (it is important), then click on OK.
- 1. Now you can run the new configuration. It will build the project, call SBT
- to package and copy JARs, then run ImageJ with new plugins installed.
-
-
-### Using Eclipse ###
-
-You can generate Eclipse project using [sbteclipse](https://github.com/typesafehub/sbteclipse)
-plugin. Then go through steps similar as described above for IDEA. The only significant difference
-is that in Eclipse you add the `sbt-imagej-prepare-run` Ant target by defining new Ant builder.
-
diff --git a/example/build.sbt b/example/build.sbt
@@ -2,14 +2,13 @@ name := "sbt-imagej-example"
 organization := "ij-plugins.sf.net"
 version := "2.0.1"
 
-scalaVersion := "2.12.3"
+scalaVersion := "2.12.8"
 
-libraryDependencies += "net.imagej" % "ij" % "1.51p"
+libraryDependencies += "net.imagej" % "ij" % "1.52i"
 
 fork := true
 
-// Enable and customize `sbt-imagej` plugin
-enablePlugins(SbtImageJ)
+// Customize `sbt-imagej` plugin
 ijRuntimeSubDir := "sandbox"
 ijPluginsSubDir := "ij-plugins"
 ijCleanBeforePrepareRun := true
diff --git a/example/build.xml b/example/build.xml
diff --git a/example/project/build.properties b/example/project/build.properties
@@ -1,2 +1,2 @@
-sbt.version=0.13.16
+sbt.version=1.2.7
 
diff --git a/example/project/plugin.sbt b/example/project/plugin.sbt
@@ -1,3 +1,3 @@
 resolvers += "Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots"
 
-addSbtPlugin("net.sf.ij-plugins" % "sbt-imagej" % "2.0.1")
+addSbtPlugin("net.sf.ij-plugins" % "sbt-imagej" % "2.0.2-SNAPSHOT")
diff --git a/project/build.properties b/project/build.properties
@@ -1,2 +1 @@
-sbt.version=0.13.16
-
+sbt.version=1.2.7
diff --git a/project/sbt-sonatype.sbt b/project/sbt-sonatype.sbt
@@ -1,4 +1,4 @@
 // [https://github.com/xerial/sbt-sonatype]
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1")
-
-addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "2.3")
+// [https://github.com/sbt/sbt-pgp]
+addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.2")
diff --git a/publish.sbt b/publish.sbt
@@ -0,0 +1,16 @@
+// @formatter:off
+
+publishMavenStyle := true
+
+publishArtifact in Test := false
+
+publishTo := version {
+  version: String =>
+    val nexus = "https://oss.sonatype.org/"
+    if (version.contains("-SNAPSHOT"))
+      Some("snapshots" at nexus + "content/repositories/snapshots")
+    else
+      Some("releases"  at nexus + "service/local/staging/deploy/maven2")
+}.value
+
+pomIncludeRepository := { _ => false }
diff --git a/src/main/scala/net/ij_plugins/sf/sbt/imagej/SbtImageJ.scala b/src/main/scala/net/ij_plugins/sf/sbt/imagej/SbtImageJ.scala
@@ -139,6 +139,9 @@ object SbtImageJ extends sbt.AutoPlugin {
     )
   )
 
+
+  override def trigger = allRequirements
+
   /**
     * Run ImageJ; pointing it to created plugins.
     */
@@ -147,6 +150,7 @@ object SbtImageJ extends sbt.AutoPlugin {
                       runtimeDir: String,
                       classpath: Classpath,
                       taskStreams: TaskStreams) {
+    // val logger = sbt.Keys.streams.value.log
     val logger = taskStreams.log
     val userDir = (base / runtimeDir).getCanonicalPath
     logger.debug("Run ImageJ with -ijpath " + userDir)
@@ -165,6 +169,7 @@ object SbtImageJ extends sbt.AutoPlugin {
                              dependencies: Seq[Attributed[File]],
                              taskStreams: TaskStreams
                             ): Seq[java.io.File] = {
+    // val logger = sbt.Keys.streams.value.log
     val logger = taskStreams.log
     val pluginsDir = base / runtimeDir / "plugins" / pluginsSubDir
     logger.debug("Preparing ImageJ plugin directory: " + pluginsDir.getCanonicalPath)

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-sbt.version=0.13.16`
	`1`	`+sbt.version=1.2.7`
`2`	`2`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`resolvers += "Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots"`
`2`	`2`
`3`		`-addSbtPlugin("net.sf.ij-plugins" % "sbt-imagej" % "2.0.1")`
	`3`	`+addSbtPlugin("net.sf.ij-plugins" % "sbt-imagej" % "2.0.2-SNAPSHOT")`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1 @@`
`1`		`-sbt.version=0.13.16`
`2`		`-`
	`1`	`+sbt.version=1.2.7`