Back to Questions
730
views2
comments
Manual compilation
websharpercompiler

Hi,

first of all: nice project! I'm pleasantly surprised at the quality and usability of the tools and code. Quite a pleasure to work with.

I have a question regarding manually controlling compilation of <JavaScript> modules.

My project structure is roughly as follows:

1
2
3

sln -> ProjectA (F# Server .exe) 
    |  ProjectB (F#/WebSharper Core library) 
    |  ProjectC (WebSharper library)

ProjectA is a pure F# console application with a compilation step built-in for the browser-side code in ProjectC. It shares some code with ProjectC via ProjectB.

Both, ProjectB and ProjectC reference WebSharper directly with [<JavaScript>] attributes at the module-level, and have the <WebSharperProject>Library</WebSharperProject> tag in their respective project files.

The compilation step in ProjectA looks like this (adapted from http://www.fssnip.net/rP):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

  type AR = IntelliFactory.Core.AssemblyResolution.AssemblyResolver

  let compile (expr: Expr) : string option =
    let basepath =
        let uri = new UriBuilder(Assembly.GetExecutingAssembly().CodeBase);
        let path = Uri.UnescapeDataString(uri.Path);
        Path.GetDirectoryName(path) 

    let loader fn =
      let ldr = FE.Loader.Create (AR.Create()) (eprintfn "%O")
      Path.Combine(basepath, fn)
      |> ldr.LoadFile 

    let options =
      { FE.Options.Default with
          References =
            List.map loader [
              // These contain the JavaScript implementation for most of the standard library
              "WebSharper.Main.dll"
              "WebSharper.Collections.dll"
              "WebSharper.Control.dll"
              "WebSharper.JQuery.dll"
              "ProjectB.dll"
              "ProjectC.dll"
              // Add any other assemblies used in the quotation...
            ] }

    let compiler = FE.Prepare options (sprintf "%A" >> System.Diagnostics.Debug.WriteLine)

    compiler.Compile expr
    |> Option.map (fun e -> e.ReadableJavaScript)

In ProjectA I compile a main function from ProjectCs Main module, which itself references a bunch of code in ProjectC and ProjectB but the total output is only this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

(function()
{
 var Global=this,Runtime=this.IntelliFactory.Runtime,Iris,Web,Main,EntryPoint;
 Runtime.Define(Global,{
  WebSharper:{
   EntryPoint:{
    Example:Runtime.Field(function()
    {
     return Main.main(null);
    })
   }
  }
 });
 Runtime.OnInit(function()
 {
  Iris=Runtime.Safe(Global.Iris);
  Web=Runtime.Safe(Iris.Web);
  Main=Runtime.Safe(Web.Main);
  return EntryPoint=Runtime.Safe(Global.WebSharper.EntryPoint);
 });
 Runtime.OnLoad(function()
 {
  EntryPoint.Example();
  return;
 });
}());

My question is thus: which steps could I be missing in order to be able to structure my project like this? I would like to compile my client side code manually in order to be able to specify multiple, differently named outputs in one step.

Is this possible? How come my output is so small, even though I added all the info to the .fsproj files and WebSharper does compile the libraries with the metadata?

Thanks,

Karsten

.

I think WebSharper.Warp is closely related to what you are trying to achieve.

Try to change the compiler.Compile expr to

1
2

let asm = Assembly.GetCallingAssembly()
compiler.Compile(<@ () @>, context = asm)

(got that from WebSharper.Warp code) Hope this help.

By on 11/23/2015 6:33 AM ()

Hey, thanks for you answer! I have not tried this yet, but will do soon! I ended up working around this differently for now, but I'd still like to have a way to do this manually.

By on 11/26/2015 1:28 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper