"""The common class for the CMD and the GUI"""

def __init__(self, quiet=False):

self.quiet = quiet

self.logger = None

self.output_package_json = True

self.settings = self.get_settings()

self._project_dir = ''

self._output_dir = ''

self._progress_text = ''

self._output_err = ''

self._extract_error = ''

self._project_name = None

self.original_packagejson = {}

self.readonly = True

self.update_json = True

self.file_tree = FileTree()

def init(self):

self.logger = config.getLogger(__name__)

self.update_nw_versions(None)

self.setup_nw_versions()

def update_nw_versions(self, button):

self.progress_text = 'Updating nw versions...'

self.get_versions()

self.progress_text = '\nDone.\n'

def setup_nw_versions(self):

"""Get the nw versions stored in the local file"""

nw_version = self.get_setting('nw_version')

nw_version.values = []

try:

ver_file = get_data_file_path(config.VER_FILE)

with codecs.open(ver_file, encoding='utf-8') as f:

for line in f:

nw_version.values.append(line.strip())

except IOError:

pass

def get_nw_versions(self):

"""Get the already downloaded nw versions from the settings"""

nw_version = self.get_setting('nw_version')

return nw_version.values[:]

def get_settings(self):

"""Load all of the settings from the settings config file"""

config_file = config.get_file(config.SETTINGS_FILE)

contents = codecs.open(config_file, encoding='utf-8').read()

config_io = StringIO(contents)

config_obj = ConfigObj(config_io, unrepr=True).dict()

settings = {'setting_groups': []}

setting_items = (list(config_obj['setting_groups'].items()) +

[('export_settings', config_obj['export_settings'])] +

[('compression', config_obj['compression'])])

for setting_group, setting_group_dict in setting_items:

settings[setting_group] = {}

for setting_name, setting_dict in setting_group_dict.items():

for key, val in setting_dict.items():

if '_callback' in key:

setting_dict[key] = getattr(self, setting_dict[key])

setting_obj = Setting(name=setting_name, **setting_dict)

settings[setting_group][setting_name] = setting_obj

sgroup_items = config_obj['setting_groups'].items()

for setting_group, setting_group_dict in sgroup_items:

settings['setting_groups'].append(settings[setting_group])

self._setting_items = (

list(config_obj['setting_groups'].items()) +

[('export_settings', config_obj['export_settings'])] +

[('compression', config_obj['compression'])]

)

config_obj.pop('setting_groups')

config_obj.pop('export_settings')

config_obj.pop('compression')

self._setting_items += config_obj.items()

for key, val in config_obj.items():

settings[key] = val

return settings

def project_dir(self):

"""Get the stored project_dir"""

return self._project_dir

def output_dir(self):

"""Get the stored output_dir"""

return self._output_dir

def project_name(self):

"""Get the project name"""

return (self._project_name or

os.path.basename(os.path.abspath(self.project_dir())))

def sub_output_pattern(self, pattern, tag_dict=None):

"""

byte_pattern = bytearray(pattern.encode())

val_dict = tag_dict or self.get_tag_value_dict()

start = 0

end = 0

in_sub = False

i = 0

while i < len(byte_pattern):

char = chr(byte_pattern[i])

next_char = None

if i != len(byte_pattern) - 1:

next_char = chr(byte_pattern[i+1])

if char == '%':

if next_char == '(':

start = i

in_sub = True

if in_sub:

end = i

if char == ')':

in_sub = False

old_string = str(byte_pattern[start:end+1], 'utf-8')

sub = val_dict.get(old_string)

if sub is not None:

sub = str(sub)

byte_pattern[start:end+1] = sub.encode()

i = i + (len(sub)-len(old_string))

i += 1

return str(byte_pattern, 'utf-8')

def get_tag_dict(self):

"""

tag_dict = {}

for setting_group in (self.settings['setting_groups'] +

[self.settings['export_settings']] +

[self.settings['compression']]):

for key in setting_group.keys():

setting = setting_group[key]

tag_dict[setting.display_name] = '%('+key+')'

tag_dict['System'] = '%(system)'

tag_dict['Architecture'] = '%(arch)'

tag_dict['Short System'] = '%(sys)'

tag_dict['Platform'] = '%(platform)'

return tag_dict

def get_tag_value_dict(self):

"""

tag_dict = {}

for setting_group in (self.settings['setting_groups'] +

[self.settings['export_settings']] +

[self.settings['compression']]):

for key in setting_group.keys():

setting = setting_group[key]

tag_dict['%('+key+')'] = setting.value

return tag_dict

def get_setting(self, name):

"""Get a setting by name

for setting_group in (self.settings['setting_groups'] +

[self.settings['export_settings']] +

[self.settings['compression']]):

if name in setting_group:

setting = setting_group[name]

return setting

def show_error(self, error):

"""Show an error using the logger"""

if self.logger is not None:

self.logger.error(error)

def enable_ui_after_error(self):

"""

pass

def get_default_nwjs_branch(self):

"""

query_api = False

nwjs_branch_path = get_data_file_path(config.NW_BRANCH_FILE)

if os.path.exists(nwjs_branch_path):

mod_time = os.path.getmtime(nwjs_branch_path)

mod_time = datetime.fromtimestamp(mod_time)

hour_ago = datetime.now() - timedelta(hours=1)

if mod_time <= hour_ago:

query_api = True

else:

query_api = True

branch = None

if query_api:

github_url = self.settings['version_info']['github_api_url']

resp = utils.urlopen(github_url)

json_string = resp.read().decode('utf-8')

data = json.loads(json_string)

branch = data['default_branch']

with codecs.open(nwjs_branch_path, 'w', encoding='utf-8') as f:

f.write(branch)

else:

with codecs.open(nwjs_branch_path, 'r', encoding='utf-8') as f:

branch = f.read().strip()

return branch

def get_versions(self):

"""Get the versions from the NW.js Github changelog"""

if self.logger is not None:

self.logger.info('Getting versions...')

union_versions = set()

current_branch = self.get_default_nwjs_branch()

for urlTuple in self.settings['version_info']['urls']:

url, regex = urlTuple

url = url.format(current_branch)

response = utils.urlopen(url)

html = response.read().decode('utf-8')

nw_version = self.get_setting('nw_version')

old_versions = set(nw_version.values)

old_versions = old_versions.union(union_versions)

new_versions = set(re.findall(regex, html))

union_versions = old_versions.union(new_versions)

versions = sorted(union_versions,

key=Version, reverse=True)

filtered_vers = []

for v in versions:

ver = Version(v)

if ver.major > 0 or (ver.major == 0 and ver.minor >= 13):

filtered_vers.append(v)

versions = filtered_vers

nw_version.values = versions

f = None

try:

ver_path = get_data_file_path(config.VER_FILE)

with codecs.open(ver_path, 'w', encoding='utf-8') as f:

for v in nw_version.values:

f.write(v+os.linesep)

except IOError:

exc_format = utils.format_exc_info(sys.exc_info)

self.show_error(exc_format)

self.enable_ui_after_error()

finally:

if f:

f.close()

def download_file_with_error_handling(self):

"""

setting = self.files_to_download.pop()

location = (self.get_setting('download_dir').value or

config.download_path())

version = self.selected_version()

path = setting.url.format(version, version)

sdk_build_setting = self.get_setting('sdk_build')

sdk_build = sdk_build_setting.value

if sdk_build:

path = utils.replace_right(path, 'nwjs', 'nwjs-sdk', 1)

try:

return self.download_file(setting.url.format(version, version),

setting)

except (Exception, KeyboardInterrupt):

if os.path.exists(setting.save_file_path(version, location)):

os.remove(setting.save_file_path(version, location))

exc_format = utils.format_exc_info(sys.exc_info())

self.show_error(exc_format)

self.enable_ui_after_error()

def load_package_json(self, json_path=None):

"""Load the package.json in the project or from json_path

self.logger.info('Loading package.json')

if json_path is not None:

p_json = [json_path]

else:

p_json = glob.glob(utils.path_join(self.project_dir(),

'package.json'))

setting_list = []

if p_json:

json_str = ''

try:

with codecs.open(p_json[0], 'r', encoding='utf-8') as f:

json_str = f.read()

except IOError:

return setting_list

try:

setting_list = self.load_from_json(json_str)

except ValueError as e: # Json file is invalid

self.logger.warning('Warning: Json file invalid.')

self.progress_text = '{}\n'.format(e)

return setting_list

def process_app_settings(self, dic):

"""Process the app settings into the dic"""

for setting_name, setting in self.settings['app_settings'].items():

if setting.value is not None and setting.value != '':

dic[setting_name] = setting.value

if setting_name == 'keywords':

dic[setting_name] = re.findall('\w+', setting.value)

else:

dic.pop(setting_name, '')

def process_window_settings(self, dic):

"""Process the window settings into the dic"""

for setting_name, setting in self.settings['window_settings'].items():

if setting.value is not None and setting.value != '':

if setting.type == 'int':

try:

dic['window'][setting_name] = int(setting.value)

except ValueError:

pass

else:

dic['window'][setting_name] = setting.value

else:

dic['window'].pop(setting_name, '')

def process_webkit_settings(self, dic):

"""Process the webkit settings into the dic"""

for setting_name, setting in self.settings['webkit_settings'].items():

if setting.value is not None and setting.value != '':

dic['webkit'][setting_name] = setting.value

else:

dic['webkit'].pop(setting_name, '')

def process_webexe_settings(self, dic, global_json):

"""Set the web2exe settings based on remaining options

if not global_json:

dl_export_items = (list(self.settings['download_settings'].items()) +

list(self.settings['export_settings'].items()) +

list(self.settings['compression'].items()) +

list(self.settings['web2exe_settings'].items()))

else:

dl_export_items = (list(self.settings['download_settings'].items()) +

list(self.settings['export_settings'].items()) +

list(self.settings['compression'].items()))

for setting_name, setting in dl_export_items:

if setting.value is not None:

dic['webexe_settings'][setting_name] = setting.value

def generate_web2exe_json(self, global_json=False):

"""Generates web2exe's settings json"""

self.logger.info('Generating web2exe json file...')

web2exe_dic = {'webexe_settings': {}}

self.process_webexe_settings(web2exe_dic, global_json)

return json.dumps(web2exe_dic, indent=4, sort_keys=True)

def generate_project_json(self):

"""Generates the json config files for the exported app"""

self.logger.info('Generating package.json...')

dic = {}

dic.update({'webkit': {}, 'window': {}})

dic.update(self.original_packagejson)

self.process_app_settings(dic)

self.process_window_settings(dic)

self.process_webkit_settings(dic)

return json.dumps(dic, indent=4, sort_keys=True)

@property

def extract_error(self):

"""Get the current extract error"""

return self._extract_error

@extract_error.setter

def extract_error(self, value):

"""Write the extract error to the terminal"""

if value is not None and not self.quiet:

self._extract_error = value

sys.stderr.write('\r{}'.format(self._extract_error))

sys.stderr.flush()

@property

def output_err(self):

"""Get the current error"""

return self._output_err

@output_err.setter

def output_err(self, value):

"""Write an error to the terminal"""

if value is not None and not self.quiet:

self._output_err = value

sys.stderr.write('\r{}'.format(self._output_err))

sys.stderr.flush()

@property

def progress_text(self):

"""Get the progress text currently set"""

return self._progress_text

@progress_text.setter

def progress_text(self, value):

"""Write progress text to the terminal

if value is not None and not self.quiet:

self._progress_text = value

sys.stdout.write('\r{}'.format(self._progress_text))

sys.stdout.flush()

def load_from_json(self, json_str):

"""Load settings from the supplied json string

dic = json.loads(json_str)

self.original_packagejson.update(dic)

setting_list = []

stack = [('root', dic)]

while stack:

parent, new_dic = stack.pop()

for item in new_dic:

setting = self.get_setting(item)

if setting:

if (setting.type == 'file' or

setting.type == 'string' or

setting.type == 'folder' or

setting.type == 'int'):

val_str = self.convert_val_to_str(new_dic[item])

setting.value = val_str

if setting.type == 'strings':

ditem = new_dic[item]

strs = self.convert_val_to_str(ditem).split(',')

strs = [x.strip() for x in strs if x]

setting.value = strs

if setting.type == 'check':

setting.value = new_dic[item]

if setting.type == 'list':

val_str = self.convert_val_to_str(new_dic[item])

setting.value = val_str

if setting.type == 'range':

setting.value = new_dic[item]

setting_list.append(setting)

if isinstance(new_dic[item], dict):

stack.append((item, new_dic[item]))

return setting_list

def selected_version(self):

"""Get the currently selected version from the NW.js dropdown"""

return self.get_setting('nw_version').value

def extract_files(self):

"""Extract nw.js files to the specific version path"""

self.extract_error = None

location = (self.get_setting('download_dir').value or

config.download_path())

sdk_build_setting = self.get_setting('sdk_build')

sdk_build = sdk_build_setting.value

version = self.selected_version()

for setting_name, setting in self.settings['export_settings'].items():

save_file_path = setting.save_file_path(version,

location,

sdk_build)

try:

if setting.value:

extract_path = get_data_path('files/'+setting.name)

setting.extract(extract_path, version, save_file_path,

sdk_build)

self.progress_text += '.'

except (tarfile.ReadError, zipfile.BadZipfile) as e:

if os.path.exists(save_file_path):

os.remove(save_file_path)

self.extract_error = e

self.logger.error(self.extract_error)

# cannot use GUI in thread to notify user. Save it for later

self.progress_text = '\nDone.\n'

return True

def create_icns_for_app(self, icns_path):

"""

icon_setting = self.get_setting('icon')

mac_app_icon_setting = self.get_setting('mac_icon')

icon_path = (mac_app_icon_setting.value

if mac_app_icon_setting.value

else icon_setting.value)

if icon_path:

icon_path = utils.path_join(self.project_dir(), icon_path)

if not icon_path.endswith('.icns'):

save_icns(icon_path, icns_path)

else:

utils.copy(icon_path, icns_path)

def replace_icon_in_exe(self, exe_path):

"""Modifies the nw.js executable to have the project icon

icon_setting = self.get_setting('icon')

exe_icon_setting = self.get_setting('exe_icon')

icon_path = (exe_icon_setting.value

if exe_icon_setting.value

else icon_setting.value)

if icon_path:

p = PEFile(exe_path)

p.replace_icon(utils.path_join(self.project_dir(), icon_path))

p.write(exe_path)

p = None

def write_package_json(self):

"""Collects filled options and writes corresponding json files"""

json_file = utils.path_join(self.project_dir(), 'package.json')

w2e_json_file = utils.path_join(self.project_dir(),

config.WEB2EXE_JSON_FILE)

global_json = utils.get_data_file_path(config.GLOBAL_JSON_FILE)

if not self.readonly and self.update_json:

# Write package json

if self.output_package_json:

with codecs.open(json_file, 'w+', encoding='utf-8') as f:

f.write(self.generate_project_json())

if self.update_json:

with codecs.open(w2e_json_file,

'w+', encoding='utf-8') as f:

f.write(self.generate_web2exe_json())

# Write global settings that are kept when installing new

# versions

with codecs.open(global_json, 'w+', encoding='utf-8') as f:

f.write(self.generate_web2exe_json(global_json=True))

def clean_dirs(self, *dirs):

"""

for directory in dirs:

if os.path.exists(directory):

utils.rmtree(directory, onerror=self.remove_readonly)

if not os.path.exists(directory):

os.makedirs(directory)

def get_export_path(self, ex_setting, name_pattern):

"""Get the export destination path using the export setting

tag_dict = {

'%(system)': ex_setting.system,

'%(sys)': ex_setting.short_system,

'%(arch)': ex_setting.arch,

'%(platform)': ex_setting.name

}

dest = self.sub_output_pattern(name_pattern, tag_dict)

if dest == name_pattern:

dest = utils.path_join(name_pattern, ex_setting.name)

return dest

def copy_export_files(self, ex_setting, export_dest):

"""Copy the export files to the destination path

if os.path.exists(export_dest):

utils.rmtree(export_dest)

# shutil will make the directory for us

utils.copytree(get_data_path('files/'+ex_setting.name),

export_dest,

ignore=shutil.ignore_patterns('place_holder.txt'))

utils.rmtree(get_data_path('files/'+ex_setting.name))

def replace_localized_app_name(self, app_path):

"""

strings_path = utils.path_join(app_path,

'Contents',

'Resources',

'en.lproj',

'InfoPlist.strings')

strings = open(strings_path, mode='rb').read()

strings = str(strings)

strings = strings.replace('nwjs', self.project_name())

with open(strings_path, mode='wb+') as f:

f.write(bytes(strings, 'utf-8'))

def replace_plist(self, app_path):

"""Replaces the Info.plist file with the project settings

plist_path = utils.path_join(app_path, 'Contents', 'Info.plist')

plist_dict = plistlib.readPlist(plist_path)

plist_dict['CFBundleDisplayName'] = self.project_name()

plist_dict['CFBundleName'] = self.project_name()

version_setting = self.get_setting('version')

if version_setting.value is not None:

plist_dict['CFBundleShortVersionString'] = version_setting.value

plist_dict['CFBundleVersion'] = version_setting.value

else:

plist_dict['CFBundleShortVersionString'] = '0.0.0'

plist_dict['CFBundleVersion'] = '0.0.0'

plistlib.writePlist(plist_dict, plist_path)

def process_mac_setting(self, app_loc, export_dest,

ex_setting):

"""Process the Mac settings

app_path = utils.path_join(export_dest,

self.project_name()+'.app')

nw_path = utils.path_join(export_dest, 'nwjs.app')

self.compress_nw(nw_path, ex_setting)

utils.move(nw_path, app_path)

self.replace_plist(app_path)

resource_path = utils.path_join(

app_path,

'Contents',

'Resources'

)

app_nw_res = utils.path_join(resource_path, 'app.nw')

if self.uncompressed:

utils.copytree(app_loc, app_nw_res)

else:

utils.copy(app_loc, app_nw_res)

self.progress_text += '.'

self.create_icns_for_app(utils.path_join(resource_path,

'app.icns'))

self.create_icns_for_app(utils.path_join(resource_path,

'document.icns'))

self.replace_localized_app_name(app_path)

self.progress_text += '.'

def process_win_linux_setting(self, app_loc, export_dest,

ex_setting):

"""Processes windows and linux settings

nw_path = utils.path_join(export_dest,

ex_setting.binary_location)

ext = ''

if 'windows' in ex_setting.name:

ext = '.exe'

self.replace_icon_in_exe(nw_path)

self.compress_nw(nw_path, ex_setting)

dest_binary_path = utils.path_join(export_dest,

self.project_name() +

ext)

if 'linux' in ex_setting.name:

self.make_desktop_file(dest_binary_path, export_dest)

self.copy_executable(export_dest, dest_binary_path,

nw_path, app_loc)

self.set_executable(dest_binary_path)

self.progress_text += '.'

if os.path.exists(nw_path):

os.remove(nw_path)

def process_export_setting(self, ex_setting, output_name):

"""Create the executable based on the export setting"""

if ex_setting.value:

self.progress_text = '\n'

name = ex_setting.display_name

self.progress_text = 'Making files for {}...'.format(name)

temp_dir = utils.path_join(config.TEMP_DIR, 'webexectemp')

name_path = self.get_export_path(ex_setting, output_name)

output_dir = utils.path_join(self.output_dir(), name_path)

self.clean_dirs(temp_dir, output_dir)

app_loc = self.get_app_nw_loc(temp_dir, output_dir)

self.copy_export_files(ex_setting, output_dir)

self.progress_text += '.'

if 'mac' in ex_setting.name:

self.process_mac_setting(app_loc, output_dir, ex_setting)

else:

self.process_win_linux_setting(app_loc, output_dir,

ex_setting)

@property

def used_project_files(self):

return self.file_tree.files

@property

def used_project_dirs(self):

return self.file_tree.dirs

def make_output_dirs(self, write_json=True):

"""Create the output directories for the application to be copied"""

output_name = self.sub_pattern() or self.project_name()

self.progress_text = 'Making new directories...\n'

whitelist_setting = self.get_setting('whitelist')

blacklist_setting = self.get_setting('blacklist')

output_blacklist = os.path.basename(self.output_dir())

blacklist_vals = re.split(',?\n?', blacklist_setting.value)

whitelist_vals = re.split(',?\n?', whitelist_setting.value)

self.file_tree.init(self.project_dir(),

blacklist=(blacklist_vals +

['*'+output_blacklist+'*']),

whitelist=whitelist_vals)

self.copy_files_to_project_folder()

if write_json:

self.write_package_json()

self.file_tree.refresh()

for ex_setting in self.settings['export_settings'].values():

self.process_export_setting(ex_setting, output_name)

@property

def uncompressed(self):

"""Returns true if the exported app is to be uncompressed"""

uncomp_setting = self.get_setting('uncompressed_folder')

return uncomp_setting.value

def sub_pattern(self):

"""Returns the output pattern substitution or an empty string"""

setting = self.get_setting('output_pattern')

return self.sub_output_pattern(setting.value)

def try_make_output_dirs(self):

"""Try to create the output directories if they don't exist"""

self.output_err = ''

try:

self.make_output_dirs()

except Exception:

exc_format = utils.format_exc_info(sys.exc_info)

self.logger.error(exc_format)

self.output_err += exc_format

finally:

temp_dir = utils.path_join(config.TEMP_DIR, 'webexectemp')

utils.rmtree(temp_dir, onerror=self.remove_readonly)

def get_app_nw_loc(self, temp_dir, output_dir):

"""Copy the temporary app to the output_dir"""

app_file = utils.path_join(temp_dir, self.project_name()+'.nw')

proj_dir = self.project_dir()

if self.uncompressed:

app_nw_folder = utils.path_join(temp_dir,

self.project_name()+'.nwf')

for dir in self.used_project_dirs:

if not os.path.exists(dir):

os.makedirs(dir)

for file in self.used_project_files:

src = utils.path_join(proj_dir, file)

dest = utils.path_join(app_nw_folder, file)

base, _ = os.path.split(dest)

if not os.path.exists(base):

os.makedirs(base)

utils.copy(src, dest)

return app_nw_folder

else:

zip_files(app_file, proj_dir, *self.used_project_files)

return app_file

def get_version_tuple(self):

"""Get the currently selected version's tuple of major, minor, release

try:

strs = re.findall('(\d+)\.(\d+)\.(\d+)',

self.selected_version())[0]

except IndexError:

strs = ['0','0','0']

return [int(s) for s in strs]

def copy_executable(self, export_path, dest_path,

nw_path, app_loc):

"""

package_loc = utils.path_join(export_path, 'package.nw')

if self.uncompressed:

utils.copytree(app_loc, package_loc)

utils.copy(nw_path, dest_path)

else:

join_files(dest_path, nw_path, app_loc)

def set_executable(self, path):

"""Modify the path to be executable by the OS"""

sevenfivefive = (stat.S_IRWXU |

stat.S_IRGRP |