juliagizmos / jsexpr.jl Goto Github PK

onjs(myobs, @js @async function()
    # Option 1: auto-await
    @var foo = @jl calculate_something()
    @async @jl println("foo!")
    # Option 2: manual-await
    @var foo = @await @jl calculate_something()
    @jl println("foo!")
end)

julia> @js (a,b) -> a*sin(b)
JSString("(function (a,b){return (a*sin(b))})")

cur_key_map = Dict(
  "left" => [37, 65],
  "up" => [38, 87],
  "right" => [39, 68],
  "down" => [40, 83],
  "clock" => [69],
  "counter" => [81]
)

cur_container = dom"div[tabindex=1]"(
  cur_table,=
  events=Dict(
    "keyup" =>
      @js function (cur_event)
        cur_key_code = cur_event.keyCode;

        # Pseudocode of what the uncommented code below does // what i'm asking about: (top)

        # for (cur_key, cur_values) in cur_key_map
        #   for cur_value in cur_values
        #     if ( cur_key_code == cur_value ) ; $cur_observer[] = cur_key ; end
        #   end
        # end

        # Pseudocode of what the uncommented code below does // what i'm asking about: (bot)

        if ( cur_key_code == 37 ) ; $cur_observer[] = "left" ; end
        if ( cur_key_code == 38 ) ; $cur_observer[] = "up" ; end
        if ( cur_key_code == 39 ) ; $cur_observer[] = "right" ; end
        if ( cur_key_code == 40 ) ; $cur_observer[] = "down" ; end

        if ( cur_key_code == 65 ) ; $cur_observer[] = "left" ; end
        if ( cur_key_code == 87 ) ; $cur_observer[] = "up" ; end
        if ( cur_key_code == 68 ) ; $cur_observer[] = "right" ; end
        if ( cur_key_code == 83 ) ; $cur_observer[] = "down" ; end

        if ( cur_key_code == 81 ) ; $cur_observer[] = "counter" ; end
        if ( cur_key_code == 69 ) ; $cur_observer[] = "clock" ; end
      end
  )
)

@js :(
      e ->
        console.log("woof")
        $cur_observer[] = e.keyCode
        console.log("bark")
    ))

pkg> add JSExpr@1.0.0
  Resolving package versions...
ERROR: Unsatisfiable requirements detected for package JSExpr [97c1335a]:
 JSExpr [97c1335a] log:
 ├─possible versions are: [0.3.0-0.3.1, 0.4.0, 0.5.0-0.5.2] or uninstalled
 └─restricted to versions 1.0.0 by an explicit requirement — no versions left

cur_html = """
  <script class="cs-step-script">
    var cur_parent = \$(".cs-step-script").parent();
    cur_parent.css("padding", 0);

    \$(".js-active-piece").removeClass();

    var cur_grand_parent = cur_parent.parent();
    if ( !cur_grand_parent.hasClass("cs-visual") ) {
      cur_grand_parent.remove();
    }
  </script>
"""

display(HTML(cur_html))

@js window console.log("foo")

# In JSExpr
macro js(target, expr)
    return :(js($(esc(target), ...))
end

# In Blink
function JSExpr.js(w::Window, code::JSString)
    # Evaluate the JS code in the Blink window
end

# Generic placeholder for the production rules for parsing Julia AST to
# JavaScript JS. Expects a Val'ed head Symbol of the expression, and
# overloads on handled signatures of the args vector of the expression.
# The return should always be a JSAST. Delete in actual implementation.
function crawl(head::Val{juliasymbol}, args...)::JSAST end

# Generic placeholder for overriding function calls. Delete in actual implementation.
function crawl(c::Val{:call}, head::Val{juliasymbol}, args...)::JAST end

# Generic placeholder for overriding marco calls. Delete in actual implementation.
function crawl(m::Val{:macro}, head::Val{juliasymbol}, args...)::JAST end

# Generic placeholder for the production rules for parsing JavaScript AST
# to String's. Expects a Val'ed head Symbol of the JS expression, and
# the a vector JSAST sub-expressions. The return should always be a String.
# Delete in actual implementation.
function deparse(head::Val{jssymbol}, args::Vector{JSAST})::String end

# Note, any string can be turned into a symbol with a call to the Symbol() 
# constructor, so jshead really can store anything. Likewise symbols can be
# returned to strings through a call to the String() constructor.
struct JSAST
    jshead::Symbol
    jsbody::Vector{JSAST}
    function JSAST(
        h::Symbol,
        b::Union{Vector{JSAST}, Vararg{JSAST, N}} = Vector{JSAST}()
    ) where N
        if isa(b, Vector{JSAST})
            return new(h, b)
        else
            return new(h, [b...])
        end
    end
end

# Dumps the raw JS string literal into the argument of the parent 
# expression that the macro was called from. The common use 
# cases are for the macro to be called as the RHS of an assignment,
# or an interpolation into another literal.
macro js(ex)
    return Expr(:call, :JSString, deparse(crawl(ex)))
end

# The expectation is that each dispatched crawl function returns a JS AST
# by calling the crawl-function recursively on deeper expressions.
# Potentially unsafe catch all for terminals.
function crawl(ex::Expr)::JSAST

    # Recurse into expressions
    if hasmethod(crawl, typeof((Val(ex.head), ex.args...)))
        return crawl(Val(ex.head), ex.args...)::JSAST

    # Bail and explain
    else
        error("Expression $ex not supported.")
    end
end

# Protect string terminals
function crawl(ex::String)
    return JSAST(Symbol(string("\"", ex, "\"")))
end

# No coercion on symbols
function crawl(ex::Symbol)
    return JSAST(ex)
end

# All other terminals
function crawl(ex::T)::JSAST

    # Push terminals that have native symbol methods, maybe unsafe
    if hasmethod(Symbol, Tuple{T})
        return JSAST(Symbol(ex))

    # Push terminals, when all else fails try interpolation. This will be a source of bugs
    # because there are no guarantees the string representation will be sensible.
    elseif hasmethod(string, Tuple{T})
        return JSAST(Symbol(string(ex)))

    # Bail and explain
    else
        error(
            "The type $T cannot be a terminal node because " *
            "neither a string method nor a Symbol method were found."
        )
    end
end

# The expectation is that each dispatched deparse function returns a bare JSString
# literal, formed by appropriate ordering and concatenation of the output of 
# recursive calls to the deparse-function.
function deparse(ex::JSAST)::String
    if length(ex.body) == 0
        return string(ex.head)
    else
        return deparse(Val(ex.head), ex.jsbody)::String
    end
end

# Allow override-able parsing of calls
function crawl(h::Val{:call}, m::Symbol, b...)::JSAST

    # Check for overrides
    if hasmethod(crawl, typeof((Val(:call), Val(m), b...)))
        return crawl(Val(:call), Val(m), b...)::JSAST

    # Otherwise pass as a call
    else
        return JSAST(:call, [crawl(m), crawl.(b)...])
    end
end

# Allow override-able parsing of macros
function crawl(h::Val{:macrocall}, m::Symbol, l::LineNumberNode, b...)::JSAST

    # Check for overrides
    if hasmethod(crawl, typeof((Val(m), b...)))
        return crawl(Val(:macrocall), Val(m), b...)::JSAST

    # Otherwise expand and crawl the current module, but let crawl determine
    # what to do with subsequent marcos
    else
        return crawl(macroexpand(@__MODULE__, Expr(:macrocall, m, l, b...); recursive=false))::JSAST
    end
end

# Example crawl and deparse
crawl(h::Val{:ref}, lhs, rhs) = JSAST(:jsref, [crawl(lhs), crawl(rhs)])
deparse(h::Val(:jsref), b::Vector{JSAST}) = string(
    deparse(b[1])::String,
    "[",
    deparse(b[2])::String,
    "]"
)

# Assignmet
crawl(h::Val{:(=)}, lhs, rhs) = JSAST(:jsref, [crawl(lhs), crawl(rhs)])
deparse(h::Val{:(=)}, b::Vector{JSAST}) = string(deparse(lhs), "=", deparse(rhs))

# Objects
function crawl(h::Val{:tuple}, b::Vararg{Expr, N})::JSAST where N
    js = JSAST(:object)
    for ex in b
        if ex.head == :(=)
            push!(js.body, crawl(ex))
        else
            error("Expression $ex is not a named argument in the tuple.")
        end
    end
    return js
end
function deparse(h::Val{:object}, b::Vector{JSAST})::String
    if length(b) > 0
        js = fill(",", 2*length(b) - 1)
        js[1:2:2*length(b) - 1] = deparse.(b)
        js = string("{", js..., "}")
    else
        js = "{}"
    end
    return js
end

# Arrays
function crawl(h::Val{:vec}, b...)::JSAST where N
    return JSAST(:vec, crawl.(b))
end
function deparse(h::Val{:vec}, b::Vector{JSAST})::String
    if length(b) > 0
        js = fill(",", 2*length(b) - 1)
        js[1:2:2*length(b) - 1] = deparse.(b)
        js = string("[", js..., "]")
    else
        js = "[]"
    end
    return js
end

# Escape JS macros, treat as terminals
function crawlmacro(h::Val{Symbol("@js-str")}, b::String)
    return crawl(b)::JSAST
end

# Escape new macros
function crawlmacro(h::Val{Symbol("@new")}, b...)
    return JSAST(:new, crawl.(b))
end
function deparse(h::Val{:new}, b::Vector{JSAST})
    return string("new", " ", deparse(b))
end

# Escape var macros
function crawlmacro(h::Val{Symbol("@var")}, b...)
    return JSAST(:var, crawl.(b))
end
function deparse(h::Val{:var}, b::Vector{JSAST})
    return string("var", " ", deparse(b))
end

import JSExpr.crawl
import JSExpr.deparse

# Override the intrinsic JSExpr crawl to check for single argument ref's.
crawl(h::Val{:ref}, b) = JSAST(:WebIOref, crawl(b))

# Override the intrinsic JSExpr deparse to check for single argument
# ref's. Call the intrinsic method when there are multiple arguments
function deparse(h::Val{:(=)}, b::Vector{JSAST})::String

    # The left and right hand sides are empty ref's, short circuit to a 
    # chained set-get.
    if b[1].head == :WebIOref && b[2].head == :WebIOref
        return string(
            "WebIO.setval(", 
            deparse(Val(b[1].body[1].head), b[1].body[1].body)::String,
            ", WebIO.getval(",
            deparse(Val(b[2].body[1].head), b[2].body[1].body)::String, 
            "))"
        )

    # Only the left hand side is an empty ref, call set
    elseif b[1].head == :WebIOref
        return string(
            "WebIO.setval(",
            deparse(Val(b[1].body[1].head), b[1].body[1].body)::String,
            " , ",
            deparse(Val(b[2].head), b[2].body)::String,
            ")"
        )

    # Only the right hand side is an empty ref, call get
    elseif b[2].head == :WebIOref
        return string(
            deparse(Val(b[1].head), b[1].body)::String,
            " = WebIO.getval(",
            deparse(Val(b[2].body[1].head), b[2].body[1].body)::String,
            ")"
        )

    # Otherwise call the intrinsic method
    else
        return JSExpr.deparse(h, b)::String
    end
end

julia> module Foo
         import JSExpr: @new, jsexpr
         f() = jsexpr(:(@new Int(1)))
       end
WARNING: replacing module Foo
Foo

julia> Foo.f()
ERROR: JSExpr: Unsupported `error` expression, $(Expr(:error, UndefVarError(Symbol("@new"))))
Stacktrace:
 [1] macro expansion at /home/rdeits/Downloads/blink-bug/packages/v0.6/JSExpr/src/JSExpr.jl:191 [inlined]
 [2] macro expansion at /home/rdeits/Downloads/blink-bug/packages/v0.6/MacroTools/src/macro.jl:18 [inlined]
 [3] jsexpr(::Expr) at /home/rdeits/Downloads/blink-bug/packages/v0.6/JSExpr/src/JSExpr.jl:159
 [4] macro expansion at /home/rdeits/Downloads/blink-bug/packages/v0.6/JSExpr/src/JSExpr.jl:179 [inlined]
 [5] macro expansion at /home/rdeits/Downloads/blink-bug/packages/v0.6/MacroTools/src/macro.jl:18 [inlined]
 [6] jsexpr(::Expr) at /home/rdeits/Downloads/blink-bug/packages/v0.6/JSExpr/src/JSExpr.jl:159
 [7] f() at ./REPL[12]:3

julia> @macroexpand @js $(x)
:((JSExpr.JSString)((JSExpr.string)((JSExpr.jsexpr)(x))))

julia> @macroexpand @js $(x.y)
:((JSExpr.JSString)((JSExpr.string)((JSExpr.jsexpr)(x.y))))

julia> @macroexpand @js $(x.y.z)
:((JSExpr.JSString)((JSExpr.string)((JSExpr.join)((JSExpr.map)(JSExpr.jsexpr, x), ","))))