I have a directory tree which looks like the following:
|- src
| \- stuff
| \- app
|- target
| \- stuff
| \- app
I have the following in a rakefile:
include 'rake/clean'
CLEAN.include 'target'
CLEAN.exclude 'target/stuff'
My intention is to have the tree end up like the following:
|- src
| \- stuff
| \- app
|- target
| \- stuff
Obviously in my example above this could be done with CLEAN.include 'target/app' but my actual layout is more complex.
Is there a way to exclude target/app from getting cleaned but still clean everything else in the target directory? If not, what is the point of having CLEAN.exclude in the api?
I agree that exclude does not seem to behave as expected. Here's what I did to work around this:
Dir['target/*'].each do |file|
CLEAN.include file unless file == 'stuff'
end
Related
I have an IntelliJ project in scala with the following directory structure (I've renamed files/directories for simplicity):
project
|
+--src
| |
| +--main
| | |
| | +--scala
| | |
| | +--'X'
| | |
| | +--'Y.scala'
| +--test
| |
| +--scala
| |
| +--'X'
| |
| +--'YSuite.scala'
|
+--build.sbt
The issue I'm having is that I'm able to import things in the YSuite.scala file that I'm not able to in YSuite.scala - specifically, the scala.collections.parallel packages. I just have no idea how or why I can import in the test file, but not in the parallel application file. I need them in the main file for implementation. Can someone point me in the right direction?
Screenshots are of the Y.scala file, YSuite.scala file, as well as the build.sbt file, if they help at all.
As can be seen, the red text indicates that I wasn't able to import it in Y.scala - when I hover over it with my mouse, it simply says cannot resolve symbol parallel. However, I've run the test file with some implementation of the parallel package, which runs with no problems.
Y.scala
YSuite.scala
build.sbt
a solution that seems to have worked for me:
step 1: File -> Invalidate Caches / Restart
step 2: build again/spin up sbt
We used to structure projects on Gitlab in groups named after the client. Is it possible to group projects together in Azure DevOps within an organization? The desired state looks something like this
Organization
|
|- Company 1
| \
| |- Project for Company 1
| |- Project2 for Company 1
|
|- Company 2
| \
| |- Project for Company 2
Currently, the structure is flat
Organization
|
|- Project for Company 1
|- Project2 for Company 1
|- Project for Company 2
It is not, each project lives under the root organization.
What you would want to do is probably create a Team Project for each company, then use separate teams and area paths to split out the work items for each project. Work items can be split by subteam, but repos and pipelines roll up at the Team Project level so you would have to use the Team to limit access.
Organization
|
|- Company 1
| \
| |- Team for Project1 (which creates a new area path where the work items are stored)
| |- Team for Project2 (which creates a new area path where the work items are stored)
|
|- Company 2
| \
| |- Team for Project (which creates a new area path where the work items are stored)
See: https://learn.microsoft.com/en-us/azure/devops/organizations/projects/about-projects?view=azure-devops
I have the following dummy project structure:
|───employee-uService
| ├───backend
| | ├───employee-api
| | ├───project
| | ├───src
| | │ └───main
| | │ ├───protobuf
| | │ └───scala
| | ├───build.sbt
| ├───build.sbt
|───build.sbt (root project build)
The build.sbt in the employee-api contains project definition with the .settings(scalapbSettings(".")) setting.
The scalapbSettings function sets up the proto source folder like:
val protoSources = PB.protoSources in Compile := Seq(file(s"$projectFolder/src/main/protobuf"))
Where the projectFolder is a parameter of the function.
The build.sbt one level higher in the hierarchy (employee-uService) defines employee-api and the respective impl project and aggregates them, while the root build aggregates the ...-uService projects.
Depending on the project I'm compiling, the given string parameter for the scalapbSettings function has to change to represent the proper path. (e.g.: in the root it has to be employee-uService/backend/employee-api while when running the api compile, it's ..
How could I pass a value to the function call that could be overwritten in the different build.sbt files?
Given the directory structure you described (protos are under src/main/protobuf in each project), you don't need to set PB.protoSources for each project since that is the default. However, if you wanted to specify it explicitly, and allow users to override, you could have in your scalapbSettings function the following line:
val protoSources = PB.protoSources in Compile := Seq(
file((sourceDirectory in Compile).value / projectFolder))
Then projectFolder should be relative to src/main (and can have default value "protobuf" of)
Tip: in an SBT shell you can type, protocSources to see what is the value of this settings for each project.
So I am writing a webapp in Eclipse and I want to use the serviceloader in one of my classes. Question is where to put the META-INF/services stuff. From here (https://stackoverflow.com/a/3421191/2742995) I found:
But the ideal way is to have it in your plugin's jar file. E.g if you
have a plugin bundled as WEB-INF/lib/myplugin.jar, and your plugin
class is com.example.plugin.MyPlugin Then the jar should have a
structure:
myplugin.jar!/META-INF/services/com.example.plugin.MyPlugin
So I have in the module containing the serviceloader stuff, the source: src/main/java/ containing
vcs.validation.* (containing the source code)
a folder: META-INF/services/vcs.validation.javatests.JavaTest containing:
Test1 (which reads vcs.validation.javatests.Test1) and
Test2 (which reads vcs.validation.javatests.Test2)
(The interface vcs.validation.javatests.JavaTest has two implementing classes Test1 and Test2)
However, when I package the whole webapp as a war and deploy in tomcat the web-app/WEB-INF/classes/ folder does not contain any META-INF/services/. What am I doing wrong here?
Structure should be:
Project
| Module
| | src
| | main
| | java
| | [ source code]
| | resources
| | META-INF
| | services
| | [service files]
instead of:
Project
| Module
| | src
| | main
| | java
| | [source code]
| | META-INF
| | services
| | [service files]
In this way the service files are no longer exploded to webapp/WEB-INF/classes/META-INF/services but just live in the jar in which they are packaged according to:
myplugin.jar!/META-INF/services/com.example.plugin.MyPlugin
I have a couple of ANT projects for several different clients; the directory structure I have for my projects looks like this:
L___standard_workspace
L___.hg
L___validation_commons-sub-proj <- JS Library/Module
| L___java
| | L___jar
| L___old_stuff
| L___src
| | L___css
| | L___js
| | L___validation_commons
| L___src-test
| L___js
L___v_file_attachment-sub-proj <- JS Library/Module
| L___java
| | L___jar
| L___src
| | L___css
| | L___js
| L___src-test
| L___js
L___z_business_logic-sub-proj <- JS Library/Module
| L___java
| | L___jar
| L___src
| L___css
| L___js
L____master-proj <- Master web-deployment module where js libraries are compiled to.
L___docs
L___java
| L___jar
| L___src
| L___AntTasks
| L___build
| | L___classes
| | L___com
| | L___company
| L___dist
| L___nbproject
| | L___private
| L___src
| L___com
| L___company
L___remoteConfig
L___src
| L___css
| | L___blueprint
| | | L___plugins
| | | | L___buttons
| | | | | L___icons
| | | | L___fancy-type
| | | | L___link-icons
| | | | | L___icons
| | | | L___rtl
| | | L___src
| | L___jsmvc
| L___img
| | L___background-shadows
| | L___banners
| | L___menu
| L___js
| | L___approve
| | L___cart
| | L___confirm
| | L___history
| | L___jsmvc
| | L___mixed
| | L___office
| L___stylesheets
| L___swf
L___src-standard
Within the working copy the modules compile the sub-project into a single Javascript file that is placed in the Javascript directory of the master project.
For example, the directories:
validation_commons-sub-proj
v_file_attachment-sub-proj
z_business_logic-sub-proj
...all are combined and minified (sort of like compiled) into a different Javascript filename in the _master-proj/js directory; and in the final step the _master-proj is compiled to be deployed to the server.
Now in regards to the way I'd like to set this up with hg, what I'd like to be able to do is clone the master project and its sub-projects from their own base-line repositories into a client's working-copy, so that modules can be added (using hg) to a particular customer's working copy.
Additionally however, when I do make some changes to/fix bugs in one customer's working copy, I would like to be able to optionally push the changes/bug fixes back to the master project/sub-project's base-line repository, for purposes of eventually pulling the changes/fixes into other customer's working copies that might contain the same bugs that need to be fixed.
In this way I will be able to utilize the same bug fixes across different clients.
However...I am uncertain of the best way to do this using hg and Eclipse.
I read here that you can use hg's Convert Extension to split a sub-directory into a separate project using the --filemap option.
However, I'm still a little bit confused as to if it would be better to use the Convert Extension or if it would be better to just house each of the modules in their own repository and check them out into a single workspace for each client.
Yep, it looks like subrepos are what you are looking for, but I think maybe that is the right answer for the wrong question and I strongly suspect that you'll run into similar issues that occur when using svn:externals
Instead I would recommend that you "publish" your combined and minified JS files to an artefact repository and use a dependency manager such as Ivy to pull specific versions of your artefacts into your master project. This approach give you far greater control over the sub-project versions your master project uses.
If you need to make bug fixes to a sub-project for a particular client, you can just make the fixes on the mainline for that sub-project, publish a new version (ideally via an automated build pipeline) and update their master project to use the new version. Oh, you wanted to test the new version with the their master project before publishing? In that case, before you push your fix, combine and minify your sub-project locally, publish it to a local repository and have the client's master project pick up that version for your testing.