Mirror_Repos/git-tfs
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cloned VS2008 to VS2010, and updated appropriately.

Browse Source
This commit is contained in:
Matt Burke
2010-05-24 12:50:15 -04:00
parent a47fbbea19
commit 7493bbe193
7 changed files with 661 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
GitTfs.Vs2010/GitTfs.Vs2010.csproj
+83
View File
@@ -0,0 +1,83 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{C5A374D3-A2E1-407C-9D6D-541FDB53BD62}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Sep.Git.Tfs.Vs2010</RootNamespace>
<AssemblyName>GitTfs.Vs2010</AssemblyName>
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<PlatformTarget>x86</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<PlatformTarget>x86</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.TeamFoundation, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="Microsoft.TeamFoundation.Client, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="Microsoft.TeamFoundation.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="Microsoft.TeamFoundation.Common.Library, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="Microsoft.TeamFoundation.VersionControl.Client, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="Microsoft.TeamFoundation.WorkItemTracking.Client, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="StructureMap, Version=2.5.3.0, Culture=neutral, PublicKeyToken=e60ad81abae3c223, processorArchitecture=MSIL">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\lib\StructureMap\StructureMap.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Xml.Linq">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data.DataSetExtensions">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="TfsApiBridge.cs" />
<Compile Include="TfsHelper.cs" />
<Compile Include="TfsPlugin.cs" />
<Compile Include="Wrappers.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\GitTfs\GitTfs.csproj">
<Project>{55C169E0-93CC-488C-9885-1D4EAF4EA236}</Project>
<Name>GitTfs</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PostBuildEvent>xcopy /y $(TargetDir)*.dll $(SolutionDir)GitTfs\$(OutDir)</PostBuildEvent>
</PropertyGroup>
</Project>
GitTfs.Vs2010/Properties/AssemblyInfo.cs
+36
View File
@@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("GitTfs.Vs2010")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyProduct("GitTfs.Vs2010")]
[assembly: AssemblyCopyright("Copyright © Microsoft 2010")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("f876a2ae-258b-4c59-8303-8399d453e748")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
GitTfs.Vs2010/TfsApiBridge.cs
+95
View File
@@ -0,0 +1,95 @@
using Microsoft.TeamFoundation.Server;
using Microsoft.TeamFoundation.VersionControl.Client;
using Sep.Git.Tfs.Core.TfsInterop;
using ChangeType=Microsoft.TeamFoundation.VersionControl.Client.ChangeType;
namespace Sep.Git.Tfs.Vs2010
{
public class TfsApiBridge
{
public IChangeset Wrap(Changeset changeset)
{
return new WrapperForChangeset(this, changeset);
}
public IChange Wrap(Change change)
{
return new WrapperForChange(this, change);
}
public IItem Wrap(Item item)
{
return new WrapperForItem(this, item);
}
public IIdentity Wrap(Identity identity)
{
return identity == null ? (IIdentity)new NullIdentity() : new WrapperForIdentity(identity);
}
public IWorkspace Wrap(Workspace workspace)
{
return new WrapperForWorkspace(this, workspace);
}
public Workspace Unwrap(IWorkspace workspace)
{
return WrapperFor<Workspace>.Unwrap(workspace);
}
public IShelveset Wrap(Shelveset shelveset)
{
return new WrapperForShelveset(this, shelveset);
}
public Shelveset Unwrap(IShelveset shelveset)
{
return WrapperFor<Shelveset>.Unwrap(shelveset);
}
public IPendingChange Wrap(PendingChange pendingChange)
{
return new WrapperForPendingChange(pendingChange);
}
public PendingChange Unwrap(IPendingChange pendingChange)
{
return WrapperFor<PendingChange>.Unwrap(pendingChange);
}
public IWorkItemCheckinInfo Wrap(WorkItemCheckinInfo workItemCheckinInfo)
{
return new WrapperForWorkItemCheckinInfo(workItemCheckinInfo);
}
public IVersionControlServer Wrap(VersionControlServer versionControlServer)
{
return new WrapperForVersionControlServer(this, versionControlServer);
}
public WorkItemCheckinInfo Unwrap(IWorkItemCheckinInfo info)
{
return WrapperFor<WorkItemCheckinInfo>.Unwrap(info);
}
public TfsChangeType Convert(ChangeType type)
{
return (TfsChangeType) (int) type;
}
public TfsItemType Convert(ItemType type)
{
return (TfsItemType) (int) type;
}
public WorkItemCheckinAction Convert(TfsWorkItemCheckinAction action)
{
return (WorkItemCheckinAction) (int) action;
}
public ShelvingOptions Convert(TfsShelvingOptions options)
{
return (ShelvingOptions) (int) options;
}
}
}
GitTfs.Vs2010/TfsHelper.cs
+181
View File
@@ -0,0 +1,181 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Server;
using Microsoft.TeamFoundation.VersionControl.Client;
using Microsoft.TeamFoundation.WorkItemTracking.Client;
using SEP.Extensions;
using Sep.Git.Tfs.Core;
using Sep.Git.Tfs.Core.TfsInterop;
using StructureMap;
namespace Sep.Git.Tfs.Vs2010
{
public class TfsHelper : ITfsHelper
{
private readonly TextWriter _stdout;
private TfsTeamProjectCollection server;
private string username;
private readonly TfsApiBridge _bridge;
public TfsHelper(TextWriter stdout, TfsApiBridge bridge)
{
_stdout = stdout;
_bridge = bridge;
}
public string TfsClientLibraryVersion
{
get { return typeof(TfsTeamProjectCollection).Assembly.GetName().Version.ToString() + " (MS)"; }
}
public string Url
{
get { return server == null ? null : server.Uri.ToString(); }
set { SetServer(value, Username); }
}
public string Username
{
get { return username; }
set
{
username = value;
SetServer(Url, value);
}
}
private void SetServer(string url, string username)
{
if(string.IsNullOrEmpty(url))
{
server = null;
}
else
{
if(string.IsNullOrEmpty(username))
{
server = new TfsTeamProjectCollection(new Uri(url));
}
else
{
server = new TfsTeamProjectCollection(new Uri(url), MakeCredentials(username));
}
}
}
private ICredentials MakeCredentials(string username)
{
throw new NotImplementedException("TODO: Using a non-default username is not yet supported.");
}
private TfsTeamProjectCollection Server
{
get
{
return server;
}
}
public VersionControlServer VersionControl
{
get
{
var versionControlServer = (VersionControlServer)Server.GetService(typeof(VersionControlServer));
versionControlServer.NonFatalError += NonFatalError;
return versionControlServer;
}
}
public WorkItemStore WorkItems
{
get
{
return (WorkItemStore) Server.GetService(typeof (WorkItemStore));
}
}
private void NonFatalError(object sender, ExceptionEventArgs e)
{
_stdout.WriteLine(e.Failure.Message);
Trace.WriteLine("Failure: " + e.Failure.Inspect(), "tfs non-fatal error");
Trace.WriteLine("Exception: " + e.Exception.Inspect(), "tfs non-fatal error");
}
private IGroupSecurityService GroupSecurityService
{
get { return (IGroupSecurityService) Server.GetService(typeof(IGroupSecurityService)); }
}
public IEnumerable<ITfsChangeset> GetChangesets(string path, long startVersion)
{
var changesets = VersionControl.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full,
null, new ChangesetVersionSpec((int) startVersion), VersionSpec.Latest, int.MaxValue, true,
true, true);
foreach (Changeset changeset in changesets)
{
yield return
new TfsChangeset(this, _bridge.Wrap(changeset))
{
Summary = new TfsChangesetInfo {ChangesetId = changeset.ChangesetId}
};
}
}
public void WithWorkspace(string localDirectory, IGitTfsRemote remote, TfsChangesetInfo versionToFetch, Action<ITfsWorkspace> action)
{
var workspace = GetWorkspace(localDirectory, remote.TfsRepositoryPath);
try
{
var tfsWorkspace = ObjectFactory.With("localDirectory").EqualTo(localDirectory)
.With("remote").EqualTo(remote)
.With("contextVersion").EqualTo(versionToFetch)
.With("workspace").EqualTo(_bridge.Wrap(workspace))
.GetInstance<TfsWorkspace>();
action(tfsWorkspace);
}
finally
{
workspace.Delete();
}
}
public IShelveset CreateShelveset(IWorkspace workspace, string shelvesetName)
{
return
_bridge.Wrap(new Shelveset(_bridge.Unwrap(workspace).VersionControlServer, shelvesetName,
workspace.OwnerName));
}
private Workspace GetWorkspace(string localDirectory, string repositoryPath)
{
var workspace = VersionControl.CreateWorkspace(GenerateWorkspaceName());
workspace.CreateMapping(new WorkingFolder(repositoryPath, localDirectory));
return workspace;
}
private string GenerateWorkspaceName()
{
return Guid.NewGuid().ToString();
}
public IIdentity GetIdentity(string username)
{
return _bridge.Wrap(GroupSecurityService.ReadIdentity(SearchFactor.AccountName, username, QueryMembership.None));
}
public IEnumerable<IWorkItemCheckinInfo> GetWorkItemInfos(IEnumerable<string> workItems, TfsWorkItemCheckinAction checkinAction)
{
return workItems.Select(workItem => _bridge.Wrap(GetWorkItemInfo(workItem, _bridge.Convert(checkinAction))));
}
private WorkItemCheckinInfo GetWorkItemInfo(string workItem, WorkItemCheckinAction checkinAction)
{
return new WorkItemCheckinInfo(WorkItems.GetWorkItem(Convert.ToInt32(workItem)), checkinAction);
}
}
}
GitTfs.Vs2010/TfsPlugin.cs
+15
View File
@@ -0,0 +1,15 @@
namespace Sep.Git.Tfs.Vs2010
{
class TfsPlugin : Sep.Git.Tfs.Core.TfsInterop.TfsPlugin
{
public override void Initialize(StructureMap.Graph.IAssemblyScanner scan)
{
base.Initialize(scan);
scan.AssemblyContainingType(typeof (Microsoft.TeamFoundation.Client.TfsTeamProjectCollection));
}
public override void Initialize(StructureMap.IInitializationExpression config)
{
}
}
}
GitTfs.Vs2010/Wrappers.cs
+245
View File
@@ -0,0 +1,245 @@
using System;
using System.Diagnostics;
using System.Linq;
using Microsoft.TeamFoundation.Server;
using Microsoft.TeamFoundation.VersionControl.Client;
using Sep.Git.Tfs.Core.TfsInterop;
namespace Sep.Git.Tfs.Vs2010
{
class WrapperForVersionControlServer :WrapperFor<VersionControlServer>, IVersionControlServer
{
private readonly TfsApiBridge _bridge;
private readonly VersionControlServer _versionControlServer;
public WrapperForVersionControlServer(TfsApiBridge bridge, VersionControlServer versionControlServer) : base(versionControlServer)
{
_bridge = bridge;
_versionControlServer = versionControlServer;
}
public IItem GetItem(int itemId, int changesetNumber)
{
return _bridge.Wrap(_versionControlServer.GetItem(itemId, changesetNumber));
}
}
class WrapperForChangeset : WrapperFor<Changeset>, IChangeset
{
private readonly TfsApiBridge _bridge;
private readonly Changeset _changeset;
public WrapperForChangeset(TfsApiBridge bridge, Changeset changeset) : base(changeset)
{
_bridge = bridge;
_changeset = changeset;
}
public IChange [] Changes
{
get { return _changeset.Changes.Select(c => _bridge.Wrap(c)).ToArray(); }
}
public string Committer
{
get { return _changeset.Committer; }
}
public DateTime CreationDate
{
get { return _changeset.CreationDate; }
}
public string Comment
{
get { return _changeset.Comment; }
}
public int ChangesetId
{
get { return _changeset.ChangesetId; }
}
}
class WrapperForChange : WrapperFor<Change>, IChange
{
private readonly TfsApiBridge _bridge;
private readonly Change _change;
public WrapperForChange(TfsApiBridge bridge, Change change) : base(change)
{
_bridge = bridge;
_change = change;
}
public TfsChangeType ChangeType
{
get { return _bridge.Convert(_change.ChangeType); }
}
public IItem Item
{
get { return _bridge.Wrap(_change.Item); }
}
}
class WrapperForItem : WrapperFor<Item>, IItem
{
private readonly TfsApiBridge _bridge;
private readonly Item _item;
public WrapperForItem(TfsApiBridge bridge, Item item) : base(item)
{
_bridge = bridge;
_item = item;
}
public IVersionControlServer VersionControlServer
{
get { return _bridge.Wrap(_item.VersionControlServer); }
}
public int ChangesetId
{
get { return _item.ChangesetId; }
}
public string ServerItem
{
get { return _item.ServerItem; }
}
public decimal DeletionId
{
get { return _item.DeletionId; }
}
public TfsItemType ItemType
{
get { return _bridge.Convert(_item.ItemType); }
}
public int ItemId
{
get { return _item.ItemId; }
}
public void DownloadFile(string file)
{
_item.DownloadFile(file);
}
}
class WrapperForIdentity : WrapperFor<Identity>, IIdentity
{
private readonly Identity _identity;
public WrapperForIdentity(Identity identity) : base(identity)
{
Debug.Assert(identity != null, "wrapped property must not be null.");
_identity = identity;
}
public string MailAddress
{
get { return _identity.MailAddress; }
}
public string DisplayName
{
get { return _identity.DisplayName; }
}
}
class WrapperForShelveset : WrapperFor<Shelveset>, IShelveset
{
private readonly Shelveset _shelveset;
private readonly TfsApiBridge _bridge;
public WrapperForShelveset(TfsApiBridge bridge, Shelveset shelveset) : base(shelveset)
{
_shelveset = shelveset;
_bridge = bridge;
}
public string Comment
{
get { return _shelveset.Comment; }
set { _shelveset.Comment = value; }
}
public IWorkItemCheckinInfo[] WorkItemInfo
{
get { return _shelveset.WorkItemInfo.Select(i => _bridge.Wrap(i)).ToArray(); }
set { _shelveset.WorkItemInfo = value.Select(i => _bridge.Unwrap(i)).ToArray(); }
}
}
class WrapperForWorkItemCheckinInfo : WrapperFor<WorkItemCheckinInfo>, IWorkItemCheckinInfo
{
private readonly WorkItemCheckinInfo _info;
public WrapperForWorkItemCheckinInfo(WorkItemCheckinInfo info) : base(info)
{
_info = info;
}
}
class WrapperForPendingChange : WrapperFor<PendingChange>, IPendingChange
{
private readonly PendingChange _pendingChange;
public WrapperForPendingChange(PendingChange pendingChange) : base(pendingChange)
{
_pendingChange = pendingChange;
}
}
class WrapperForWorkspace : WrapperFor<Workspace>, IWorkspace
{
private readonly TfsApiBridge _bridge;
private readonly Workspace _workspace;
public WrapperForWorkspace(TfsApiBridge bridge, Workspace workspace) : base(workspace)
{
_bridge = bridge;
_workspace = workspace;
}
public IPendingChange [] GetPendingChanges()
{
return _workspace.GetPendingChanges().Select(c => _bridge.Wrap(c)).ToArray();
}
public void Shelve(IShelveset shelveset, IPendingChange [] changes, TfsShelvingOptions options)
{
_workspace.Shelve(_bridge.Unwrap(shelveset), changes.Select(c => _bridge.Unwrap(c)).ToArray(), _bridge.Convert(options));
}
public int PendAdd(string path)
{
return _workspace.PendAdd(path);
}
public int PendEdit(string path)
{
return _workspace.PendEdit(path);
}
public int PendDelete(string path)
{
return _workspace.PendDelete(path);
}
public void ForceGetFile(string path, int changeset)
{
var item = new ItemSpec(path, RecursionType.None);
_workspace.Get(new GetRequest(item, changeset), GetOptions.Overwrite | GetOptions.GetAll);
}
public string OwnerName
{
get { return _workspace.OwnerName; }
}
}
}
GitTfs.sln
+6
View File
@@ -18,6 +18,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GitTfsBenchmarks", "GitTfsB
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GitTfs.Vs2008", "GitTfs.Vs2008\GitTfs.Vs2008.csproj", "{09BF8124-19A8-45BE-896B-536CA0F3F0FC}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GitTfs.Vs2010", "GitTfs.Vs2010\GitTfs.Vs2010.csproj", "{C5A374D3-A2E1-407C-9D6D-541FDB53BD62}"
EndProject
Global
GlobalSection(TestCaseManagementSettings) = postSolution
CategoryFile = GitTfs1.vsmdi
@@ -43,6 +45,10 @@ Global
{09BF8124-19A8-45BE-896B-536CA0F3F0FC}.Debug|x86.Build.0 = Debug|x86
{09BF8124-19A8-45BE-896B-536CA0F3F0FC}.Release|x86.ActiveCfg = Release|x86
{09BF8124-19A8-45BE-896B-536CA0F3F0FC}.Release|x86.Build.0 = Release|x86
{C5A374D3-A2E1-407C-9D6D-541FDB53BD62}.Debug|x86.ActiveCfg = Debug|x86
{C5A374D3-A2E1-407C-9D6D-541FDB53BD62}.Debug|x86.Build.0 = Debug|x86
{C5A374D3-A2E1-407C-9D6D-541FDB53BD62}.Release|x86.ActiveCfg = Release|x86
{C5A374D3-A2E1-407C-9D6D-541FDB53BD62}.Release|x86.Build.0 = Release|x86
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE