Moves over the binary and dsym file to the output directory
 @return (String) The path to the resulting ipa file
439349
def move_ipa
      FileUtils.mv(PackageCommandGenerator.ipa_path, File.expand_path(Gym.config[:output_directory]), force: true)
      ipa_path = File.expand_path(File.join(Gym.config[:output_directory], File.basename(PackageCommandGenerator.ipa_path)))

      UI.success("Successfully exported and signed the ipa file:")
      UI.message(ipa_path)
      ipa_path
    end
1282294
function fileToOutput(output, filePath) {
    var book = output.getBook();
    var readme = book.getReadme();
    var fileReadme = readme.getFile();

    if (
        path.basename(filePath, path.extname(filePath)) == 'README' ||
        (fileReadme.exists() && filePath == fileReadme.getPath())
    ) {
        filePath = path.join(path.dirname(filePath), 'index' + OUTPUT_EXTENSION);
    } else {
        filePath = PathUtils.setExtension(filePath, OUTPUT_EXTENSION);
    }

    return LocationUtils.normalize(filePath);
}
1341156
def _load_data(self):
        
        ipa_canonical_string_to_ascii_str = dict()
        for line in load_data_file(
            file_path=self.DATA_FILE_PATH,
            file_path_is_relative=True,
            line_format=u"sxA"
        ):
            i_desc, i_ascii = line
            if len(i_ascii) == 0:
                raise ValueError("Data file '%s' contains a bad line: '%s'" % (self.DATA_FILE_PATH, line))
            key = (variant_to_canonical_string(i_desc),)
            ipa_canonical_string_to_ascii_str[key] = i_ascii[0]
        return ipa_canonical_string_to_ascii_str
958593
def output_path(self, path_name):
                
        # make sure it is a valid posix format
        path = to_posix(path_name)
        
        assert (path == path_name), "path_name passed to output_path must be in posix format"
        
        if posixpath.isabs(path):
            if self.output == self.cache:
                # worth seeing if an absolute path can be avoided
                path = posixpath.relpath(path, self.output)

            else:
                return posixpath.realpath(path)
    
        if path.startswith('../'):
            joined = posixpath.join(self.output, path)
            return posixpath.realpath(joined)
    
        return path
908249
def save
      output_path = @options['output_path']
      staging_path = @options['staging_path']

      @assets.each do |asset|
        directory = File.join(@source, staging_path, output_path)
        write_asset_file(directory, asset)

        # Store output path of saved file
        asset.output_path = output_path
      end
    end
871758
function getOutputDir(output) {
  var arr = output.split(path.sep);
  arr.pop();
  return arr.join(path.sep);
}
10713
def process_result
      require 'sass'

      if @options[:recursive]
        process_directory
        return
      end

      super
      input = @options[:input]
      if File.directory?(input)
        raise "Error: '#{input.path}' is a directory (did you mean to use --recursive?)"
      end
      output = @options[:output]
      output = input if @options[:in_place]
      process_file(input, output)
    end
644798
def move_apps_folder
      if Dir.exist?(PackageCommandGenerator.apps_path)
        FileUtils.mv(PackageCommandGenerator.apps_path, File.expand_path(Gym.config[:output_directory]), force: true)
        apps_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.apps_path))

        UI.success("Successfully exported Apps folder:")
        UI.message(apps_path)
        apps_path
      end
    end
1055760
def compile_ui(uifile):
    
    print "Compileing: %s" % uifile
    outputpath = uifile.rsplit(os.path.extsep, 1)[0] + "_ui.py"
    print "Outputfile: %s" % outputpath
    outputfile = open(os.path.abspath(outputpath), "w")
    pysideuic.compileUi(os.path.abspath(uifile), outputfile)
    print "Done!"
113126
def _symlink_in_files(in_files, data):
    
    work_dir = utils.safe_makedir(os.path.join(data["dirs"]["work"], "align_prep"))
    out = []
    for in_file in in_files:
        out_file = os.path.join(work_dir, "%s_%s" % (dd.get_sample_name(data), os.path.basename(in_file)))
        out_file = _symlink_or_copy_grabix(in_file, out_file, data)
        out.append(out_file)
    return out
1150208
def _load_ipa_data(self, ipa_data_path):
		
		ipa = {}

		try:
			with open(ipa_data_path, newline='') as f:
				reader = csv.reader(f, delimiter='\t')
				for line in reader:
					if len(line) != 2:
						continue

					if line[0] in ipa:
						raise IPADataError('Bad IPA data file')

					ipa[line[0]] = line[1]

		except (IOError, ValueError) as err:
			self.log.error(str(err))
			raise IPADataError('Could not open the IPA data file')

		return ipa
1104103
def move_manifest
      if File.exist?(PackageCommandGenerator.manifest_path)
        FileUtils.mv(PackageCommandGenerator.manifest_path, File.expand_path(Gym.config[:output_directory]), force: true)
        manifest_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.manifest_path))

        UI.success("Successfully exported the manifest.plist file:")
        UI.message(manifest_path)
        manifest_path
      end
    end
801834
function() {
    switch (process.platform) {
      case 'darwin':
        return path.join('/Applications/Docker.app/Contents/Resources', 'bin');
      case 'linux':
        return path.join(kbox.core.deps.get('config').sysConfRoot, 'bin');
      case 'win32':
        var programFiles = process.env.ProgramW6432;
        return path.join(programFiles + '\\Docker\\Docker\\resources\\bin');
    }
  }
1036529
def output_files(self):
        
        outs = [os.path.join(self.address.repo, self.address.path, x)
                for x in self.params['outs']]
        return outs
29747
def get_binary_path(executable, logging_level='INFO'):
    """"""
    if sys.platform == 'win32':
        if executable == 'start':
            return executable
        executable = executable + '.exe'
        if executable in os.listdir('.'):
            binary = os.path.join(os.getcwd(), executable)
        else:
            binary = next((os.path.join(path, executable)
                           for path in os.environ['PATH'].split(os.pathsep)
                           if os.path.isfile(os.path.join(path, executable))), None)
    else:
        venv_parent = get_venv_parent_path()
        venv_bin_path = os.path.join(venv_parent, '.venv', 'bin')
        if not venv_bin_path in os.environ.get('PATH'):
            if logging_level == 'DEBUG':
                print(f'Adding path {venv_bin_path} to environment PATH variable')
            os.environ['PATH'] = os.pathsep.join([os.environ['PATH'], venv_bin_path])
        binary = shutil.which(executable)
    return binary if binary else None
700825
def convert_to_file(cgi_input, output_file, twobit_ref, twobit_name, var_only=False):
    """"""

    if isinstance(output_file, str):
        output_file = auto_zip_open(output_file, 'w')

    conversion = convert(cgi_input=cgi_input, twobit_ref=twobit_ref, twobit_name=twobit_name, var_only=var_only)
    for line in conversion:
        output_file.write(line + "\n")
    output_file.close()
1095965
private File getDefaultOutputDirectory()
    {
        //The default output directory is the configuration name
        String childOutputDirectory = getConfiguration();
        
        //However, for platforms others than Win32, the default output directory becomes platform/configuration
        if ( ! getPlatform().equals( "Win32" ) )
        {
            childOutputDirectory = new File( getPlatform(), childOutputDirectory ).getPath();
        }
        
        //Place the default output directory within the appropriate base directory
        return new File( getBaseDirectory(), childOutputDirectory );
    }