Saves the workspace at the given `xcworkspace` path.

 @param  [String] path
         the path where to save the project.

 @return [void]
183058
def save_as(path)
      FileUtils.mkdir_p(path)
      File.open(File.join(path, 'contents.xcworkspacedata'), 'w') do |out|
        out << to_s
      end
    end
378649
def save(self, path):
        
        # remember and restore file position
        pos = self.tell()
        self.seek(0)

        with fopen(path, 'wb') as output:
            output.truncate(self.length)
            for chunk in iter(lambda: self.read(1024), b''):
                output.write(chunk)

        self.seek(pos)
476510
public static void writeAndClose(String path) throws IOException, NoSuchMethodException, IllegalAccessException,
            InvocationTargetException {
        createXwpfDocumentIfNull();
        writeTo(path);
        xwpfDocument.close();
        xwpfDocument = new XWPFDocument();
    }
224874
def add_namespace(image, path)
      namespace path.to_sym do |_args|
        require 'rspec/core/rake_task'
        ::RSpec::Core::RakeTask.new(:spec) do |task|
          task.pattern = "#{path}/spec/*_spec.rb"
        end

        docker_image = Vtasks::Docker::Image.new(image, path, args)

        lint_image(path)

        desc 'Build and tag docker image'
        task :build do
          docker_image.build_with_tags
        end

        desc 'Publish docker image'
        task :push do
          docker_image.push
        end
      end
    end
1051678
def save_to(path)
      File.open(path, "w") do |file|
        I18n.with_locale(meta.locale) do
          file << render
        end
      end
    end
846424
def save(self, path):
        
        path = os.path.expandvars(os.path.expanduser(path))
        with open(path, "wb") as f:
            pickle.dump(self.roots, f)
70005
def load_path(self, path):
        

        if not foundations.common.path_exists(path):
            return False

        if os.path.isfile(path):
            if path in self.list_files():
                self.set_current_editor(path)
            else:
                self.load_file(path)
        else:
            if not path in self.list_projects():
                self.add_project(path)
        return True
1169985
def set(path)
      assert_exists
      path = path.to_s

      @object.setValueAttribute path

      unless @object.getContentType
        @object.setContentType(Celerity::Util.content_type_for(path))
      end

      path
    end
978306
def save(self, path):
        

        data = self.encode()

        with open(path, "wb") as out:
            out.write(data)
854928
def export(self, path, variables_saver=None):
    
    # Operate on a copy of self._proto since it needs to be modified.
    proto = saved_model_pb2.SavedModel()
    proto.CopyFrom(self._proto)
    assets_map = _make_assets_key_collection(proto, path)

    self._save_all_assets(path, assets_map)
    self._save_variables(path, variables_saver)
    self._save_proto(path, proto)
1207584
def put(self, local_path, path, atomic=True):
        
        self._connect()

        if self.sftp:
            self._sftp_put(local_path, path, atomic)
        else:
            self._ftp_put(local_path, path, atomic)

        self._close()
1317954
def save(self, name=None, path=None):
        
        if path :
            name = os.path.join(path,name)

        try:
            self._create_table_xml_file(self.etree, name)
        except (Exception,) as e:
            print(e)
            return False

        return True
391296
private boolean isInZkWathcedNamespacePaths(String path) {
        if (StringUtil.isEmpty(path)) {
            return false;
        }
        for (String watchNamespacePath : RpcClientConf.ZK_WATCH_NAMESPACE_PATHS) {
            if (StringUtil.isEmpty(watchNamespacePath)) {
                continue;
            }
            if (path.contains(watchNamespacePath)) {
                return true;
            }
        }
        return false;
    }
99914
def save_to_path(path: str, config: Config) -> None:
    
    LOG.debug(f"Saving config to {path}")
    with open(path, 'w') as cf:
        cf.write(json.dumps({k: v for k, v in config._asdict().items()
                             if k != 'path'}))
1037333
def save(self, new_path=None):
        
        self.saved_in_temp = new_path is None
        if new_path is None:
            fd, new_path = tempfile.mkstemp()
            os.close(fd)

        if self.current_path:
            shutil.move(self.current_path, new_path)
        else:
            with open(new_path, 'wb') as dest:
                _copy_stream(self._data, dest, self._size)
        self.current_path = new_path
1213815
def save(output_path)
      output_path = File.expand_path(output_path)

      create_epub do
        mimetype = Zip::ZipOutputStream::open(output_path) do |os|
          os.put_next_entry("mimetype", nil, nil, Zip::ZipEntry::STORED, Zlib::NO_COMPRESSION)
          os << "application/epub+zip"
        end
        zipfile = Zip::ZipFile.open(output_path)
        Dir.glob('**/*').each do |path|
          zipfile.add(path, path)
        end
        zipfile.commit
      end
      FileUtils.remove_entry_secure dir
    end
490505
function Namespace(path, hex) {
  this.hex = !!hex
  this.keyEncoding = hex ? 'utf8' : 'binary'

  this.path = path
  this.buffer = bytewise.encode(path)
  this.prehooks = []
  this.posthooks = []
}