internal/devserver/ts_devserver.bzl - rules_typescript - Git at Google

 # Copyright 2017 The Bazel Authors. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #    http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.

 "Simple development server"

 load("@build_bazel_rules_nodejs//internal/common:sources_aspect.bzl", "sources_aspect")
 load(
     "@build_bazel_rules_nodejs//internal/js_library:js_library.bzl",
     "write_amd_names_shim",
 )
 load(
     "@build_bazel_rules_nodejs//internal/web_package:web_package.bzl",
     "html_asset_inject",
 )

 def _ts_devserver(ctx):
     files = depset()
     for d in ctx.attr.deps:
         if hasattr(d, "node_sources"):
             files = depset(transitive = [files, d.node_sources])
         elif hasattr(d, "files"):
             files = depset(transitive = [files, d.files])

     if ctx.label.workspace_root:
         # We need the workspace_name for the target being visited.
         # Skylark doesn't have this - instead they have a workspace_root
         # which looks like "external/repo_name" - so grab the second path segment.
         # TODO(alexeagle): investigate a better way to get the workspace name
         workspace_name = ctx.label.workspace_root.split("/")[1]
     else:
         workspace_name = ctx.workspace_name

     # Create a manifest file with the sources in arbitrary order, and without
     # bazel-bin prefixes ("root-relative paths").
     # TODO(alexeagle): we should experiment with keeping the files toposorted, to
     # see if we can get performance gains out of the module loader.
     ctx.actions.write(ctx.outputs.manifest, "".join([
         workspace_name + "/" + f.short_path + "\n"
         for f in files.to_list()
     ]))

     amd_names_shim = ctx.actions.declare_file(
         "_%s.amd_names_shim.js" % ctx.label.name,
         sibling = ctx.outputs.executable,
     )
     write_amd_names_shim(ctx.actions, amd_names_shim, ctx.attr.bootstrap)

     # Requirejs is always needed so its included as the first script
     # in script_files before any user specified scripts for the devserver
     # to concat in order.
     script_files = []
     script_files.extend(ctx.files.bootstrap)
     script_files.append(ctx.file._requirejs_script)
     script_files.append(amd_names_shim)
     script_files.extend(ctx.files.scripts)
     ctx.actions.write(ctx.outputs.scripts_manifest, "".join([
         workspace_name + "/" + f.short_path + "\n"
         for f in script_files
     ]))

     devserver_runfiles = [
         ctx.executable._devserver,
         ctx.outputs.manifest,
         ctx.outputs.scripts_manifest,
     ]
     devserver_runfiles += ctx.files.static_files
     devserver_runfiles += script_files

     if ctx.file.index_html:
         injected_index = ctx.actions.declare_file("index.html")
         bundle_script = ctx.attr.serving_path
         if bundle_script.startswith("/"):
             bundle_script = bundle_script[1:]
         html_asset_inject(
             ctx.file.index_html,
             ctx.actions,
             ctx.executable._injector,
             ctx.attr.additional_root_paths + [
                 ctx.label.package,
                 "/".join([ctx.bin_dir.path, ctx.label.package]),
                 "/".join([ctx.genfiles_dir.path, ctx.label.package]),
             ],
             [f.path for f in ctx.files.static_files] + [bundle_script],
             injected_index,
         )
         devserver_runfiles += [injected_index]

     serving_arg = ""
     if ctx.attr.serving_path:
         serving_arg = "-serving_path=%s" % ctx.attr.serving_path

     packages = depset(["/".join([workspace_name, ctx.label.package])] + ctx.attr.additional_root_paths)

     # FIXME: more bash dependencies makes Windows support harder
     ctx.actions.write(
         output = ctx.outputs.executable,
         is_executable = True,
         content = """#!/bin/sh
 RUNFILES="$PWD/.."
 {main} {serving_arg} \
   -base="$RUNFILES" \
   -packages={packages} \
   -manifest={workspace}/{manifest} \
   -scripts_manifest={workspace}/{scripts_manifest} \
   -entry_module={entry_module} \
   -port={port} \
   "$@"
 """.format(
             main = ctx.executable._devserver.short_path,
             serving_arg = serving_arg,
             workspace = workspace_name,
             packages = ",".join(packages.to_list()),
             manifest = ctx.outputs.manifest.short_path,
             scripts_manifest = ctx.outputs.scripts_manifest.short_path,
             entry_module = ctx.attr.entry_module,
             port = str(ctx.attr.port),
         ),
     )
     return [DefaultInfo(
         runfiles = ctx.runfiles(
             files = devserver_runfiles,
             # We don't expect executable targets to depend on the devserver, but if they do,
             # they can see the JavaScript code.
             transitive_files = depset(ctx.files.data, transitive = [files]),
             collect_data = True,
             collect_default = True,
         ),
     )]

 ts_devserver = rule(
     implementation = _ts_devserver,
     attrs = {
         "additional_root_paths": attr.string_list(
             doc = """Additional root paths to serve static_files from.
             Paths should include the workspace name such as [\"__main__/resources\"]
             """,
         ),
         "bootstrap": attr.label_list(
             doc = "Scripts to include in the JS bundle before the module loader (require.js)",
             allow_files = [".js"],
         ),
         "data": attr.label_list(
             doc = "Dependencies that can be require'd while the server is running",
             allow_files = True,
         ),
         "entry_module": attr.string(
             doc = """The entry_module should be the AMD module name of the entry module such as `"__main__/src/index"`
             ts_devserver concats the following snippet after the bundle to load the application:
             `require(["entry_module"]);`
             """,
         ),
         "index_html": attr.label(
             allow_single_file = True,
             doc = """An index.html file, we'll inject the script tag for the bundle,
             as well as script tags for .js static_files and link tags for .css
             static_files""",
         ),
         "port": attr.int(
             doc = """The port that the devserver will listen on.""",
             default = 5432,
         ),
         "scripts": attr.label_list(
             doc = "User scripts to include in the JS bundle before the application sources",
             allow_files = [".js"],
         ),
         "serving_path": attr.string(
             # This default repeats the one in the go program. We make it explicit here so we can read it
             # when injecting scripts into the index file.
             default = "/_/ts_scripts.js",
             doc = """The path you can request from the client HTML which serves the JavaScript bundle.
             If you don't specify one, the JavaScript can be loaded at /_/ts_scripts.js""",
         ),
         "static_files": attr.label_list(
             doc = """Arbitrary files which to be served, such as index.html.
             They are served relative to the package where this rule is declared.""",
             allow_files = True,
         ),
         "deps": attr.label_list(
             doc = "Targets that produce JavaScript, such as `ts_library`",
             allow_files = True,
             aspects = [sources_aspect],
         ),
         "_devserver": attr.label(
             # For local development in rules_typescript, we build the devserver from sources.
             # This requires that we have the go toolchain available.
             # NB: this value is replaced by "//devserver:server" in the packaged distro
             # //devserver:server is the pre-compiled binary.
             # That means that our users don't need the go toolchain.
             default = Label("//devserver:devserver_bin"),
             executable = True,
             cfg = "host",
         ),
         "_injector": attr.label(
             default = "@build_bazel_rules_nodejs//internal/web_package:injector",
             executable = True,
             cfg = "host",
         ),
         "_requirejs_script": attr.label(allow_single_file = True, default = Label("@build_bazel_rules_typescript_devserver_deps//node_modules/requirejs:require.js")),
     },
     outputs = {
         "manifest": "%{name}.MF",
         "scripts_manifest": "scripts_%{name}.MF",
     },
     executable = True,
 )
 """ts_devserver is a simple development server intended for a quick "getting started" experience.

 Additional documentation at https://github.com/alexeagle/angular-bazel-example/wiki/Running-a-devserver-under-Bazel
 """

 def ts_devserver_macro(tags = [], **kwargs):
     """ibazel wrapper for `ts_devserver`

     This macro re-exposes the `ts_devserver` rule with some extra tags so that
     it behaves correctly under ibazel.

     This is re-exported in `//:defs.bzl` as `ts_devserver` so if you load the rule
     from there, you actually get this macro.

     Args:
       tags: standard Bazel tags, this macro adds a couple for ibazel
       **kwargs: passed through to `ts_devserver`
     """
     ts_devserver(
         # Users don't need to know that these tags are required to run under ibazel
         tags = tags + [
             # Tell ibazel not to restart the devserver when its deps change.
             "ibazel_notify_changes",
             # Tell ibazel to serve the live reload script, since we expect a browser will connect to
             # this program.
             "ibazel_live_reload",
         ],
         **kwargs
     )
	# Copyright 2017 The Bazel Authors. All rights reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.

	"Simple development server"

	load("@build_bazel_rules_nodejs//internal/common:sources_aspect.bzl", "sources_aspect")
	load(
	"@build_bazel_rules_nodejs//internal/js_library:js_library.bzl",
	"write_amd_names_shim",
	)
	load(
	"@build_bazel_rules_nodejs//internal/web_package:web_package.bzl",
	"html_asset_inject",
	)

	def _ts_devserver(ctx):
	files = depset()
	for d in ctx.attr.deps:
	if hasattr(d, "node_sources"):
	files = depset(transitive = [files, d.node_sources])
	elif hasattr(d, "files"):
	files = depset(transitive = [files, d.files])

	if ctx.label.workspace_root:
	# We need the workspace_name for the target being visited.
	# Skylark doesn't have this - instead they have a workspace_root
	# which looks like "external/repo_name" - so grab the second path segment.
	# TODO(alexeagle): investigate a better way to get the workspace name
	workspace_name = ctx.label.workspace_root.split("/")[1]
	else:
	workspace_name = ctx.workspace_name

	# Create a manifest file with the sources in arbitrary order, and without
	# bazel-bin prefixes ("root-relative paths").
	# TODO(alexeagle): we should experiment with keeping the files toposorted, to
	# see if we can get performance gains out of the module loader.
	ctx.actions.write(ctx.outputs.manifest, "".join([
	workspace_name + "/" + f.short_path + "\n"
	for f in files.to_list()
	]))

	amd_names_shim = ctx.actions.declare_file(
	"_%s.amd_names_shim.js" % ctx.label.name,
	sibling = ctx.outputs.executable,
	)
	write_amd_names_shim(ctx.actions, amd_names_shim, ctx.attr.bootstrap)

	# Requirejs is always needed so its included as the first script
	# in script_files before any user specified scripts for the devserver
	# to concat in order.
	script_files = []
	script_files.extend(ctx.files.bootstrap)
	script_files.append(ctx.file._requirejs_script)
	script_files.append(amd_names_shim)
	script_files.extend(ctx.files.scripts)
	ctx.actions.write(ctx.outputs.scripts_manifest, "".join([
	workspace_name + "/" + f.short_path + "\n"
	for f in script_files
	]))

	devserver_runfiles = [
	ctx.executable._devserver,
	ctx.outputs.manifest,
	ctx.outputs.scripts_manifest,
	]
	devserver_runfiles += ctx.files.static_files
	devserver_runfiles += script_files

	if ctx.file.index_html:
	injected_index = ctx.actions.declare_file("index.html")
	bundle_script = ctx.attr.serving_path
	if bundle_script.startswith("/"):
	bundle_script = bundle_script[1:]
	html_asset_inject(
	ctx.file.index_html,
	ctx.actions,
	ctx.executable._injector,
	ctx.attr.additional_root_paths + [
	ctx.label.package,
	"/".join([ctx.bin_dir.path, ctx.label.package]),
	"/".join([ctx.genfiles_dir.path, ctx.label.package]),
	],
	[f.path for f in ctx.files.static_files] + [bundle_script],
	injected_index,
	)
	devserver_runfiles += [injected_index]

	serving_arg = ""
	if ctx.attr.serving_path:
	serving_arg = "-serving_path=%s" % ctx.attr.serving_path

	packages = depset(["/".join([workspace_name, ctx.label.package])] + ctx.attr.additional_root_paths)

	# FIXME: more bash dependencies makes Windows support harder
	ctx.actions.write(
	output = ctx.outputs.executable,
	is_executable = True,
	content = """#!/bin/sh
	RUNFILES="$PWD/.."
	{main} {serving_arg} \
	-base="$RUNFILES" \
	-packages={packages} \
	-manifest={workspace}/{manifest} \
	-scripts_manifest={workspace}/{scripts_manifest} \
	-entry_module={entry_module} \
	-port={port} \
	"$@"
	""".format(
	main = ctx.executable._devserver.short_path,
	serving_arg = serving_arg,
	workspace = workspace_name,
	packages = ",".join(packages.to_list()),
	manifest = ctx.outputs.manifest.short_path,
	scripts_manifest = ctx.outputs.scripts_manifest.short_path,
	entry_module = ctx.attr.entry_module,
	port = str(ctx.attr.port),
	),
	)
	return [DefaultInfo(
	runfiles = ctx.runfiles(
	files = devserver_runfiles,
	# We don't expect executable targets to depend on the devserver, but if they do,
	# they can see the JavaScript code.
	transitive_files = depset(ctx.files.data, transitive = [files]),
	collect_data = True,
	collect_default = True,
	),
	)]

	ts_devserver = rule(
	implementation = _ts_devserver,
	attrs = {
	"additional_root_paths": attr.string_list(
	doc = """Additional root paths to serve static_files from.
	Paths should include the workspace name such as [\"__main__/resources\"]
	""",
	),
	"bootstrap": attr.label_list(
	doc = "Scripts to include in the JS bundle before the module loader (require.js)",
	allow_files = [".js"],
	),
	"data": attr.label_list(
	doc = "Dependencies that can be require'd while the server is running",
	allow_files = True,
	),
	"entry_module": attr.string(
	doc = """The entry_module should be the AMD module name of the entry module such as `"__main__/src/index"`
	ts_devserver concats the following snippet after the bundle to load the application:
	`require(["entry_module"]);`
	""",
	),
	"index_html": attr.label(
	allow_single_file = True,
	doc = """An index.html file, we'll inject the script tag for the bundle,
	as well as script tags for .js static_files and link tags for .css
	static_files""",
	),
	"port": attr.int(
	doc = """The port that the devserver will listen on.""",
	default = 5432,
	),
	"scripts": attr.label_list(
	doc = "User scripts to include in the JS bundle before the application sources",
	allow_files = [".js"],
	),
	"serving_path": attr.string(
	# This default repeats the one in the go program. We make it explicit here so we can read it
	# when injecting scripts into the index file.
	default = "/_/ts_scripts.js",
	doc = """The path you can request from the client HTML which serves the JavaScript bundle.
	If you don't specify one, the JavaScript can be loaded at /_/ts_scripts.js""",
	),
	"static_files": attr.label_list(
	doc = """Arbitrary files which to be served, such as index.html.
	They are served relative to the package where this rule is declared.""",
	allow_files = True,
	),
	"deps": attr.label_list(
	doc = "Targets that produce JavaScript, such as `ts_library`",
	allow_files = True,
	aspects = [sources_aspect],
	),
	"_devserver": attr.label(
	# For local development in rules_typescript, we build the devserver from sources.
	# This requires that we have the go toolchain available.
	# NB: this value is replaced by "//devserver:server" in the packaged distro
	# //devserver:server is the pre-compiled binary.
	# That means that our users don't need the go toolchain.
	default = Label("//devserver:devserver_bin"),
	executable = True,
	cfg = "host",
	),
	"_injector": attr.label(
	default = "@build_bazel_rules_nodejs//internal/web_package:injector",
	executable = True,
	cfg = "host",
	),
	"_requirejs_script": attr.label(allow_single_file = True, default = Label("@build_bazel_rules_typescript_devserver_deps//node_modules/requirejs:require.js")),
	},
	outputs = {
	"manifest": "%{name}.MF",
	"scripts_manifest": "scripts_%{name}.MF",
	},
	executable = True,
	)
	"""ts_devserver is a simple development server intended for a quick "getting started" experience.

	Additional documentation at https://github.com/alexeagle/angular-bazel-example/wiki/Running-a-devserver-under-Bazel
	"""

	def ts_devserver_macro(tags = [], **kwargs):
	"""ibazel wrapper for `ts_devserver`

	This macro re-exposes the `ts_devserver` rule with some extra tags so that
	it behaves correctly under ibazel.

	This is re-exported in `//:defs.bzl` as `ts_devserver` so if you load the rule
	from there, you actually get this macro.

	Args:
	tags: standard Bazel tags, this macro adds a couple for ibazel
	**kwargs: passed through to `ts_devserver`
	"""
	ts_devserver(
	# Users don't need to know that these tags are required to run under ibazel
	tags = tags + [
	# Tell ibazel not to restart the devserver when its deps change.
	"ibazel_notify_changes",
	# Tell ibazel to serve the live reload script, since we expect a browser will connect to
	# this program.
	"ibazel_live_reload",
	],
	**kwargs
	)