Problem
So, the repository I am trying to commit 50 files into has some pre-commit-hooks in place, of which I failed one.
Question
Is there a way to commit the same files again quickly, without having to select them one by one in the tedious Team -> Commit dialogue, e.g. by a hidden buffer or even a staging area like Git has?
My tools
Eclipse Version: Version: Oxygen.3a Release (4.7.3a)
Subclipse 4.2.4
No, not really. The Eclipse Synchronize view does have a changesets feature you can use to manually put your changes into changesets and you can then commit the changeset. If you are using Eclipse Mylyn this can be somewhat automated by following the Mylyn workflow. That is about it though.
Related
This is the first time I do this.
I imported a git project in eclipse.
Then I used the shell to create another branch and checkout to the new branch.
Is refreshing the imported project in Eclipse enough to tell Eclipse that we are working on the new created branch?
thanks
Right-click your project and select Team → Branch to create new branches or to switch between existing branches. You can also switch branches in the History view.
Actually, I don't think you even need to refresh the project. That is, assuming you have 'eGit' installed and your projects are already configure as git projects (they should be, because in most cases, egit does that automatically).
Whenever you run git commands on the shell (outside eclipse) egit will automatically refresh projects for you and update their status when you switch back to Eclipse.
If you are not using egit then yes, you have to refresh the projects manually, but that is all you'd have to do since running the 'git checkout my-branch' command in the shell already changed the files on disk to be those from 'my-branch'.
Actually when you are working with eclipse, eGit is a very cool tool integrated inside eclipse, which lets you do all git stuff, like
git checkout to a new branch
git create new branch
git stash
even view your unstaged changes(select files and avoid complexities caused by git add .)
and finally commit.
Read here to know more. Eclipse Egit user guide
So you get to do all version repository stuff at one place as you code.
So to answer your question, yes as you checkout a new branch even in a shell/command prompt your changes will be reflected in eclipse.
I'm a regular git user, and I'm building some shortcuts in eclipse to activate some EGit functions.
I'm a bit wary of what is EGit doing (especially the synchronize workspace operations), and I was wondering if I could make EGit show what git commands it was using.
Do you know of an option to make it log to the console, or generally, how to find out which commands got executed?
EGit does not use the git executables. It reproduces, with the help of JGit, what the executables would do.
Git executables store the versioning state of a project in a number of files under the .git folder (branches, refs, commit objects, tags and so on).
EGit and JGit do the same.
For example:
A commit with git executables:
git commit -m "My commit message"
Would be executed in Java through EGit with CommitOperation.commit(), which uses JGit's CommitCommand.call(), which builds and inserts a commit object, which are representend through files.
There is no clear mapping between EGit's UI operations and their meaning as regular git commands, at least not to my knowledge.
One can go through (EGit, JGit, git)'s code and look for what is happening under the hood, though.
EDIT: a pgm package in JGit provides the inverse mapping: "Command-line interface Git commands implemented using JGit ("pgm" stands for program)"
EDIT: A not-merged Eclipse patch exists for logging what Egit does under the hood: https://git.eclipse.org/r/#/c/103342/
Please go to .git folder of your project. There will be a log folder like in my case (D:\Repo\GIT.git\logs)
all git command executed by eclipse are logged in respective branch file.
a sample of log is
0000000000000000000000000000000000000000 27f2e02544d389eb2412c1d467cc99f1786cd662 fanishshukla 1409137288 +0530 commit (initial): First Draft for Jboss
27f2e02544d389eb2412c1d467cc99f1786cd662 6d5634200cfdf6adf7c00ae70004326d2741e3a2 fanishshukla 1409557422 +0530 commit: fast response
6d5634200cfdf6adf7c00ae70004326d2741e3a2 32dbcfa55452b1a89861f422cfc7f90d26435d8c fanishshukla 1409557443 +0530 commit: fast response
What I found here:
There's a bug regarding this requirement:
Bug 349551 - Log EGit activities into a console
https://bugs.eclipse.org/bugs/show_bug.cgi?id=349551
How about git reflog to view command history of git
I have a repository in which I've created a branch which got its development over today. But there were some changes on the trunk so I have to merge the trunk into branch then continue the process.
First I tried to use the reintegrate feature on eclipse, but I get an error:
Merge operation failed
svn: Retrieval of mergeinfo unsupported by 'http://192.168.0.1/svn/gestaoconfig'"
Then I tried to use the main tab (URL) which should be normal, but somehow all the files are marked in conflict, and the changes made on the trunk do not appear on the local development. The diff shows exactly the same files.
I've tried attached the preview message of eclipse, but I couldn't.
My environment:
local development: ubuntu 12, using eclipse helios, with svn, version
1.6.17 (r1128011).
Repository server: fedora 12, with svn, version 1.6.9 (r901367).
As a workaround you might want to check out trunk and branch separately and check whether its feasible to do manual diff and merge.
Merge operation failed
svn: Retrieval of mergeinfo unsupported by 'http://192.168.0.1/svn/gestaoconfig'"
This means that your server is not at least version 1.5. I would highly suggest to upgrade your server because merges before this revision were quite hazardous since they had to be handled entirely manually.
However reintegrate merges are designed for the case where you worked on a feature branch and want to reintegrate it into the trunk or another branch. You are not expected to continue working on a reintegrated branch (see here).
In your case you probably just want a normal merge. If you did not delete/rename/move any file/folder in the trunk nor the branch, then your tree conflict probably comes from an error in the source or target merge path (e.g. you did not specify the /trunk or /branches/mybranch in the url)
I am trying to adopt the following workflow:
git svn clone a svn repository through command line (egit doesn't support git-svn)
Open the project in eclipse with egit since I rather use egit to branch, merge, commit etc...
When i'm ready commit the changes back, I use use git svn dcommit to commit back to svn
I am having trouble with step number 2, don't understand how to import a git project, eclipse tells me i can't import it to use the same directory it's currently in because another project with the same name is already there. this is confusing.
Anyone knows how to do this ?
Also would like to hear other workflow examples that uses egit and git svn. I am aware that it is better to do it all through command line, however, I am trying to ease the move to git for fellow developers in my team, who are not used to command line interface etc...
I've worked briefly with the egit plugin (I actually recently stopped using it and just use msysgit as my Git guiclient and run it separately from Eclipse). I find Eclipse very busy as is and adding this plugin slows it down (for me at least).
What I did when setting up an already cloned project in Eclipse:
In Eclipse. File -> Import -> Existing Project into Workspace
Select root directory of project. Do NOT check copy projects into workspace. Click finish.
After project has been imported. Right click on project, go to Team -> Share Project
Select Git as a repo type, click next
Check use or create repo in parent folder of project. Since you already cloned the project it will be tracked with git. When you check this option it will show the project, the path, and the repo (.git).
Click finish and you will be all set.
I think you'd better use SubGit instead of git-svn.
SubGit works on a server side. It synchronizes all the modification between Subversion and Git repositories automatically on every incoming modification from either side.
From the client perspective SubGit enabled repository is a usual Git repository, so you may pull from and push to it. Please refer to SubGit documentation or SubGit vs. git-svn comparison for more details.
Whenever I commit some code to my SVN repository and then do a Synchronization again with the repository the "Team Synchronizing" panel shows me that there is a update to be taken on my code and it shows 0 files and just an "empty update" to update to the latest revision number (the revision number of the recent code commit which I did) in the eclipse. I am on Windows 7. I have used the same tools in Mac and it works fine. Whenever I do a commit in Mac Eclipse it automatically updates it self.
Is this a bug or is there something I am missing?
Any help would be appreciated.
I suspect that although you have Eclipse on both Mac and Windows, the SVN plugin, or the SVN connector used by that plugin, is different between your two setups.
I'm afraid I don't have details to hand, but have seen this behaviour before. The SVN integration in Eclipse makes most sense if you end up with no incoming changes after you do a commit. It seems one of the Eclipse plugins decides after commit to immediately poll for any outstanding changes. It sees that the top-level folder for your project has been updated, so marks it for update.
This is an accurate reflection of what happens in SVN - if you commit a new revision is created in the repository, but your local checkout is not at that revision until you do an update. If you run "svn info" on the command line just after a commit you will see this.