atom_shell -> electron

script/bootstrap.py

@@ -7,7 +7,7 @@ import sys
 
 from lib.config import LIBCHROMIUMCONTENT_COMMIT, BASE_URL, PLATFORM, \
                        enable_verbose_mode, is_verbose_mode, get_target_arch
-from lib.util import execute_stdout, get_atom_shell_version, scoped_cwd
+from lib.util import execute_stdout, get_electron_version, scoped_cwd
 
 
 SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
@@ -184,7 +184,7 @@ def update_node_modules(dirname, env=None):
 def update_electron_modules(dirname, target_arch):
   env = os.environ.copy()
   env['npm_config_arch']    = target_arch
-  env['npm_config_target']  = get_atom_shell_version()
+  env['npm_config_target']  = get_electron_version()
   env['npm_config_disturl'] = 'https://atom.io/download/atom-shell'
   update_node_modules(dirname, env)
 

script/bump-version.py

@@ -4,7 +4,7 @@ import os
 import re
 import sys
 
-from lib.util import execute, get_atom_shell_version, parse_version, scoped_cwd
+from lib.util import execute, get_electron_version, parse_version, scoped_cwd
 
 
 SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
@@ -18,7 +18,7 @@ def main():
   option = sys.argv[1]
   increments = ['major', 'minor', 'patch', 'build']
   if option in increments:
-    version = get_atom_shell_version()
+    version = get_electron_version()
     versions = parse_version(version.split('-')[0])
     versions = increase_version(versions, increments.index(option))
   else:

script/create-dist.py

@@ -11,11 +11,11 @@ import stat
 from lib.config import LIBCHROMIUMCONTENT_COMMIT, BASE_URL, PLATFORM, \
                        get_target_arch, get_chromedriver_version, \
                        get_platform_key
-from lib.util import scoped_cwd, rm_rf, get_atom_shell_version, make_zip, \
+from lib.util import scoped_cwd, rm_rf, get_electron_version, make_zip, \
                      execute, atom_gyp
 
 
-ATOM_SHELL_VERSION = get_atom_shell_version()
+ELECTRON_VERSION = get_electron_version()
 
 SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
 DIST_DIR = os.path.join(SOURCE_ROOT, 'dist')
@@ -86,7 +86,7 @@ def main():
   create_version()
   create_dist_zip()
   create_chrome_binary_zip('chromedriver', get_chromedriver_version())
-  create_chrome_binary_zip('mksnapshot', ATOM_SHELL_VERSION)
+  create_chrome_binary_zip('mksnapshot', ELECTRON_VERSION)
   create_ffmpeg_zip()
   create_symbols_zip()
 
@@ -140,7 +140,7 @@ def strip_binary(binary_path):
 def create_version():
   version_path = os.path.join(SOURCE_ROOT, 'dist', 'version')
   with open(version_path, 'w') as version_file:
-    version_file.write(ATOM_SHELL_VERSION)
+    version_file.write(ELECTRON_VERSION)
 
 
 def create_symbols():
@@ -155,7 +155,7 @@ def create_symbols():
 
 
 def create_dist_zip():
-  dist_name = '{0}-{1}-{2}-{3}.zip'.format(PROJECT_NAME, ATOM_SHELL_VERSION,
+  dist_name = '{0}-{1}-{2}-{3}.zip'.format(PROJECT_NAME, ELECTRON_VERSION,
                                            get_platform_key(),
                                            get_target_arch())
   zip_file = os.path.join(SOURCE_ROOT, 'dist', dist_name)
@@ -183,7 +183,7 @@ def create_chrome_binary_zip(binary, version):
 
 def create_ffmpeg_zip():
   dist_name = 'ffmpeg-{0}-{1}-{2}.zip'.format(
-      ATOM_SHELL_VERSION, get_platform_key(), get_target_arch())
+      ELECTRON_VERSION, get_platform_key(), get_target_arch())
   zip_file = os.path.join(SOURCE_ROOT, 'dist', dist_name)
 
   if PLATFORM == 'darwin':
@@ -205,7 +205,7 @@ def create_ffmpeg_zip():
 
 def create_symbols_zip():
   dist_name = '{0}-{1}-{2}-{3}-symbols.zip'.format(PROJECT_NAME,
-                                                   ATOM_SHELL_VERSION,
+                                                   ELECTRON_VERSION,
                                                    get_platform_key(),
                                                    get_target_arch())
   zip_file = os.path.join(DIST_DIR, dist_name)
@@ -217,7 +217,7 @@ def create_symbols_zip():
 
   if PLATFORM == 'darwin':
     dsym_name = '{0}-{1}-{2}-{3}-dsym.zip'.format(PROJECT_NAME,
-                                                  ATOM_SHELL_VERSION,
+                                                  ELECTRON_VERSION,
                                                   get_platform_key(),
                                                   get_target_arch())
     with scoped_cwd(DIST_DIR):

script/lib/config.py

@@ -46,12 +46,12 @@ def get_chromedriver_version():
 
 
 def s3_config():
-  config = (os.environ.get('ATOM_SHELL_S3_BUCKET', ''),
+  config = (os.environ.get('ELECTRON_S3_BUCKET', ''),
-            os.environ.get('ATOM_SHELL_S3_ACCESS_KEY', ''),
+            os.environ.get('ELECTRON_S3_ACCESS_KEY', ''),
-            os.environ.get('ATOM_SHELL_S3_SECRET_KEY', ''))
+            os.environ.get('ELECTRON_S3_SECRET_KEY', ''))
-  message = ('Error: Please set the $ATOM_SHELL_S3_BUCKET, '
+  message = ('Error: Please set the $ELECTRON_S3_BUCKET, '
-             '$ATOM_SHELL_S3_ACCESS_KEY, and '
+             '$ELECTRON_S3_ACCESS_KEY, and '
-             '$ATOM_SHELL_S3_SECRET_KEY environment variables')
+             '$ELECTRON_S3_SECRET_KEY environment variables')
   assert all(len(c) for c in config), message
   return config
 

script/lib/util.py

@@ -187,7 +187,7 @@ def atom_gyp():
     return obj['variables']
 
 
-def get_atom_shell_version():
+def get_electron_version():
   return 'v' + atom_gyp()['version%']
 
 

script/test.py

@@ -21,18 +21,18 @@ def main():
     config = 'R'
 
   if sys.platform == 'darwin':
-    atom_shell = os.path.join(SOURCE_ROOT, 'out', config,
+    electron = os.path.join(SOURCE_ROOT, 'out', config,
                               '{0}.app'.format(PRODUCT_NAME), 'Contents',
                               'MacOS', PRODUCT_NAME)
   elif sys.platform == 'win32':
-    atom_shell = os.path.join(SOURCE_ROOT, 'out', config,
+    electron = os.path.join(SOURCE_ROOT, 'out', config,
                               '{0}.exe'.format(PROJECT_NAME))
   else:
-    atom_shell = os.path.join(SOURCE_ROOT, 'out', config, PROJECT_NAME)
+    electron = os.path.join(SOURCE_ROOT, 'out', config, PROJECT_NAME)
 
   returncode = 0
   try:
-    subprocess.check_call([atom_shell, 'spec'] + sys.argv[1:])
+    subprocess.check_call([electron, 'spec'] + sys.argv[1:])
   except subprocess.CalledProcessError as e:
     returncode = e.returncode
 

script/upload-index-json.py

@@ -18,14 +18,14 @@ def main():
   # Upload the index.json.
   with scoped_cwd(SOURCE_ROOT):
     if sys.platform == 'darwin':
-      atom_shell = os.path.join(OUT_DIR, '{0}.app'.format(PRODUCT_NAME),
+      electron = os.path.join(OUT_DIR, '{0}.app'.format(PRODUCT_NAME),
                                 'Contents', 'MacOS', PRODUCT_NAME)
     elif sys.platform == 'win32':
-      atom_shell = os.path.join(OUT_DIR, '{0}.exe'.format(PROJECT_NAME))
+      electron = os.path.join(OUT_DIR, '{0}.exe'.format(PROJECT_NAME))
     else:
-      atom_shell = os.path.join(OUT_DIR, PROJECT_NAME)
+      electron = os.path.join(OUT_DIR, PROJECT_NAME)
     index_json = os.path.relpath(os.path.join(OUT_DIR, 'index.json'))
-    execute([atom_shell,
+    execute([electron,
              os.path.join('tools', 'dump-version-info.js'),
              index_json])
 

script/upload.py

@@ -9,13 +9,13 @@ import tempfile
 
 from lib.config import PLATFORM, get_target_arch, get_chromedriver_version, \
                        get_platform_key
-from lib.util import atom_gyp, execute, get_atom_shell_version, parse_version, \
+from lib.util import atom_gyp, execute, get_electron_version, parse_version, \
                      scoped_cwd
 from lib.github import GitHub
 
 
-ATOM_SHELL_REPO = 'electron/electron'
+ELECTRON_REPO = 'electron/electron'
-ATOM_SHELL_VERSION = get_atom_shell_version()
+ELECTRON_VERSION = get_electron_version()
 
 PROJECT_NAME = atom_gyp()['project_name%']
 PRODUCT_NAME = atom_gyp()['product_name%']
@@ -24,15 +24,15 @@ SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
 OUT_DIR = os.path.join(SOURCE_ROOT, 'out', 'R')
 DIST_DIR = os.path.join(SOURCE_ROOT, 'dist')
 DIST_NAME = '{0}-{1}-{2}-{3}.zip'.format(PROJECT_NAME,
-                                         ATOM_SHELL_VERSION,
+                                         ELECTRON_VERSION,
                                          get_platform_key(),
                                          get_target_arch())
 SYMBOLS_NAME = '{0}-{1}-{2}-{3}-symbols.zip'.format(PROJECT_NAME,
-                                                    ATOM_SHELL_VERSION,
+                                                    ELECTRON_VERSION,
                                                     get_platform_key(),
                                                     get_target_arch())
 DSYM_NAME = '{0}-{1}-{2}-{3}-dsym.zip'.format(PROJECT_NAME,
-                                              ATOM_SHELL_VERSION,
+                                              ELECTRON_VERSION,
                                               get_platform_key(),
                                               get_target_arch())
 
@@ -45,16 +45,16 @@ def main():
       create_dist = os.path.join(SOURCE_ROOT, 'script', 'create-dist.py')
       execute([sys.executable, create_dist])
 
-    build_version = get_atom_shell_build_version()
+    build_version = get_electron_build_version()
-    if not ATOM_SHELL_VERSION.startswith(build_version):
+    if not ELECTRON_VERSION.startswith(build_version):
       error = 'Tag name ({0}) should match build version ({1})\n'.format(
-          ATOM_SHELL_VERSION, build_version)
+          ELECTRON_VERSION, build_version)
       sys.stderr.write(error)
       sys.stderr.flush()
       return 1
 
   github = GitHub(auth_token())
-  releases = github.repos(ATOM_SHELL_REPO).releases.get()
+  releases = github.repos(ELECTRON_REPO).releases.get()
   tag_exists = False
   for release in releases:
     if not release['draft'] and release['tag_name'] == args.version:
@@ -68,7 +68,7 @@ def main():
     # Upload the SHASUMS.txt.
     execute([sys.executable,
              os.path.join(SOURCE_ROOT, 'script', 'upload-checksums.py'),
-             '-v', ATOM_SHELL_VERSION])
+             '-v', ELECTRON_VERSION])
 
     # Upload the index.json.
     execute([sys.executable,
@@ -81,24 +81,24 @@ def main():
     return
 
   # Upload atom-shell with GitHub Releases API.
-  upload_atom_shell(github, release, os.path.join(DIST_DIR, DIST_NAME))
+  upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME))
-  upload_atom_shell(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
+  upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
   if PLATFORM == 'darwin':
-    upload_atom_shell(github, release, os.path.join(DIST_DIR, DSYM_NAME))
+    upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME))
 
   # Upload free version of ffmpeg.
   ffmpeg = 'ffmpeg-{0}-{1}-{2}.zip'.format(
-      ATOM_SHELL_VERSION, get_platform_key(), get_target_arch())
+      ELECTRON_VERSION, get_platform_key(), get_target_arch())
-  upload_atom_shell(github, release, os.path.join(DIST_DIR, ffmpeg))
+  upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg))
 
   # Upload chromedriver and mksnapshot for minor version update.
   if parse_version(args.version)[2] == '0':
     chromedriver = 'chromedriver-{0}-{1}-{2}.zip'.format(
         get_chromedriver_version(), get_platform_key(), get_target_arch())
-    upload_atom_shell(github, release, os.path.join(DIST_DIR, chromedriver))
+    upload_electron(github, release, os.path.join(DIST_DIR, chromedriver))
     mksnapshot = 'mksnapshot-{0}-{1}-{2}.zip'.format(
-        ATOM_SHELL_VERSION, get_platform_key(), get_target_arch())
+        ELECTRON_VERSION, get_platform_key(), get_target_arch())
-    upload_atom_shell(github, release, os.path.join(DIST_DIR, mksnapshot))
+    upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot))
 
   if PLATFORM == 'win32' and not tag_exists:
     # Upload PDBs to Windows symbol server.
@@ -114,28 +114,28 @@ def main():
 def parse_args():
   parser = argparse.ArgumentParser(description='upload distribution file')
   parser.add_argument('-v', '--version', help='Specify the version',
-                      default=ATOM_SHELL_VERSION)
+                      default=ELECTRON_VERSION)
   parser.add_argument('-p', '--publish-release',
                       help='Publish the release',
                       action='store_true')
   return parser.parse_args()
 
 
-def get_atom_shell_build_version():
+def get_electron_build_version():
   if get_target_arch() == 'arm' or os.environ.has_key('CI'):
     # In CI we just build as told.
-    return ATOM_SHELL_VERSION
+    return ELECTRON_VERSION
   if PLATFORM == 'darwin':
-    atom_shell = os.path.join(SOURCE_ROOT, 'out', 'R',
+    electron = os.path.join(SOURCE_ROOT, 'out', 'R',
                               '{0}.app'.format(PRODUCT_NAME), 'Contents',
                               'MacOS', PRODUCT_NAME)
   elif PLATFORM == 'win32':
-    atom_shell = os.path.join(SOURCE_ROOT, 'out', 'R',
+    electron = os.path.join(SOURCE_ROOT, 'out', 'R',
                               '{0}.exe'.format(PROJECT_NAME))
   else:
-    atom_shell = os.path.join(SOURCE_ROOT, 'out', 'R', PROJECT_NAME)
+    electron = os.path.join(SOURCE_ROOT, 'out', 'R', PROJECT_NAME)
 
-  return subprocess.check_output([atom_shell, '--version']).strip()
+  return subprocess.check_output([electron, '--version']).strip()
 
 
 def dist_newer_than_head():
@@ -192,17 +192,17 @@ def create_release_draft(github, tag):
     sys.exit(0)
 
   data = dict(tag_name=tag, name=name, body=body, draft=True)
-  r = github.repos(ATOM_SHELL_REPO).releases.post(data=data)
+  r = github.repos(ELECTRON_REPO).releases.post(data=data)
   return r
 
 
-def upload_atom_shell(github, release, file_path):
+def upload_electron(github, release, file_path):
   # Delete the original file before uploading in CI.
   if os.environ.has_key('CI'):
     try:
       for asset in release['assets']:
         if asset['name'] == os.path.basename(file_path):
-          github.repos(ATOM_SHELL_REPO).releases.assets(asset['id']).delete()
+          github.repos(ELECTRON_REPO).releases.assets(asset['id']).delete()
           break
     except Exception:
       pass
@@ -211,18 +211,18 @@ def upload_atom_shell(github, release, file_path):
   params = {'name': os.path.basename(file_path)}
   headers = {'Content-Type': 'application/zip'}
   with open(file_path, 'rb') as f:
-    github.repos(ATOM_SHELL_REPO).releases(release['id']).assets.post(
+    github.repos(ELECTRON_REPO).releases(release['id']).assets.post(
         params=params, headers=headers, data=f, verify=False)
 
 
 def publish_release(github, release_id):
   data = dict(draft=False)
-  github.repos(ATOM_SHELL_REPO).releases(release_id).patch(data=data)
+  github.repos(ELECTRON_REPO).releases(release_id).patch(data=data)
 
 
 def auth_token():
-  token = os.environ.get('ATOM_SHELL_GITHUB_TOKEN')
+  token = os.environ.get('ELECTRON_GITHUB_TOKEN')
-  message = ('Error: Please set the $ATOM_SHELL_GITHUB_TOKEN '
+  message = ('Error: Please set the $ELECTRON_GITHUB_TOKEN '
              'environment variable, which is your personal token')
   assert token, message
   return token