Fetching dll-infos and their references from a source directory.

findrefs.fsx

open System
open System.IO
open System.Net
open System.Reflection

let ``not in gac`` (filename:string) =
    try
       Assembly.Load filename |> ignore
       false
    with | :? IOException -> true

let ``assembly and references`` (filename:string) = 
    try
        let dll = Assembly.LoadFile filename
        let name = dll.GetName().Name
        match ``not in gac`` name with
        | false -> None
        | true -> 
            let references = 
                dll.GetReferencedAssemblies()
                |> Seq.filter (fun f -> f.Name |> ``not in gac``)
                |> Seq.map (fun f -> f.Name, f.Version.ToString())
            Some(dll.GetName().Name, dll.GetName().Version.ToString(), references)
    with 
    | :? BadImageFormatException -> None

let ``parse assemblies from`` path = 
    Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories)
    |> Seq.choose ``assembly and references``
    |> Seq.distinctBy (fun (n,_,_)->n)
    |> Seq.toArray

let generateDependencyFile path =
    printfn "Calculating dependency-file, please wait a while..."
    let files = ``parse assemblies from`` path
    seq {
       yield "source " + path
       yield ""
       for (name,ver,refs) in files do
           yield "file " + name.Replace(" ", "-") + " " + ver
    }

let generateLockFile path =
    printfn "Calculating lock-file, please wait a while..."
    let files = ``parse assemblies from`` path
    seq {
       yield "FILESHARE"
       yield "  remote: " + path
       yield "  specs:"
       for (name,ver,refs) in files do
           yield "    " + name.Replace(" ", "-") + " (" + ver + ")"
           yield! refs |> Seq.map (fun (n, v) -> "      " + n.Replace(" ", "-") + " (" + v + ")")
    }

let path = @"C:\3rdPartyDlls\"

let writeDependencies lines = File.WriteAllLines(@"c:\paket.test.dependencies",lines |> Seq.toArray)
generateDependencyFile path |> writeDependencies
let writeLock lines = File.WriteAllLines(@"c:\paket.test.lock",lines |> Seq.toArray)
generateLockFile path |> writeLock

nuget.fsx

// Fetching Nuget data via OData TypeProvider
#if INTERACTIVE
#r "FSharp.Data.TypeProviders"
#r "System.Data.Services.Client"
#else
module PackageManager
#endif

type Nuget = Microsoft.FSharp.Data.TypeProviders.ODataService<"https://nuget.org/api/v2">
let NugetConnection = Nuget.GetDataContext()
// NugetConnection.Credentials <- ...

let fetchNugetInfo id version = 
    try
        query { for package in NugetConnection.Packages do
                where (package.Id = id && package.Version = version)
                select (package.Title, package.IsLatestVersion)
                headOrDefault
        } |> Some
    with //Not found:
    | :? System.Data.Services.Client.DataServiceClientException -> None
    | :? System.Data.Services.Client.DataServiceQueryException -> None

let searchNuget name version = 
    (name, fetchNugetInfo name version)
    |> function 
       | n, Some(title, true) -> printfn "%s is up-to-date: %s" title n
       | n, Some(title, false) -> printfn "%s is outdated: %s" title n
       | n, _ ->  printfn "Not found: %s" n

//searchNuget "EntityFramework" "6.0.0.0" 

let readDependencyFile =
    let spaces = Seq.filter(fun f -> f = ' ') >> Seq.length
    System.IO.File.ReadAllLines(@"paket.dependencies")
    |> Seq.filter (fun itm -> spaces itm = 2)
    |> Seq.map(fun f -> 
        let x = f.Split(' ')
        x.[1], x.[2] )
    |> Seq.map(fun (n,v) -> n, searchNuget n v)
    |> Seq.toArray