DELETE /pages/1
 DELETE /pages/1.xml
5590
def destroy
      @page = ::Page.find(params[:id])
      @page.destroy

      respond_to do |format|
        format.html { redirect_to(cmtool.pages_path) }
        format.xml  { head :ok }
      end
    end
1297945
private void doRemoveDatasource() throws PageException {
	admin.removeDataSource(getString("admin", action, "name"));
	store();
	adminSync.broadcast(attributes, config);
    }
916737
public function delete()
    {     
        Util::delTree( $this->getPath() );
        foreach (Server::enum() as $s) {
            $tname = str_replace( THEME_DIR.'/', '', $s->templateDir );
            if ($tname == $this->name) {
                $s->setTheme();
            }
        }
    }
1211242
public function sectionStylesDelete()
	{
		$filename = Eresus_CMS::getLegacyKernel()->froot . 'style/'.arg('delete');
		if (file_exists($filename))
		{
			unlink($filename);
		}
		HTTP::redirect(Eresus_Kernel::app()->getPage()->url());
	}
967101
def destroy
      @question_sheet.destroy
      
      respond_to do |format|
        format.html { redirect_to admin_question_sheets_path }
        format.xml  { head :ok }
      end
    end
1295998
def removepage(self, page):
    
    try:
      self._api_entrypoint.removePage(self._session_token, page)
    except XMLRPCError as e:
      raise ConfluenceError('Failed to delete page: %s' % e)
683403
def invalidate(self):
        """"""

        cache.delete(self.PAGE_LANGUAGES_KEY % (self.id))
        cache.delete('PAGE_FIRST_ROOT_ID')
        self._languages = None
        self._complete_slug = None
        self._content_dict = dict()

        p_names = [p.name for p in get_placeholders(self.get_template())]
        if 'slug' not in p_names:
            p_names.append('slug')
        if 'title' not in p_names:
            p_names.append('title')
        # delete content cache, frozen or not
        for name in p_names:
            # frozen
            cache.delete(PAGE_CONTENT_DICT_KEY % (self.id, name, 1))
            # not frozen
            cache.delete(PAGE_CONTENT_DICT_KEY % (self.id, name, 0))

        cache.delete(self.PAGE_URL_KEY % (self.id))
1256148
public function actionClearAll()
    {
        $module = \jacmoe\mdpages\Module::getInstance();

        if($this->confirm('Delete content and data directories ?')) {
            FileHelper::removeDirectory(Yii::getAlias($module->pages_directory));
            FileHelper::removeDirectory(Yii::getAlias($module->flywheel_config));
            FileHelper::removeDirectory(Yii::getAlias('@app/web') . DIRECTORY_SEPARATOR . 'avatars');
            $this->stdout("\nContent and data and avatars directories deleted.\n", Console::FG_GREEN);
        } else {
            $this->stdout("Nothing was deleted - command interrupted.\n", Console::FG_GREEN);
        }
    }
1117982
def invalidate(self):
        """"""

        cache.delete(self.PAGE_LANGUAGES_KEY % (self.pk))
        cache.delete('PAGE_FIRST_ROOT_ID')
        cache.delete(self.CHILDREN_KEY % self.pk)
        cache.delete(self.PUB_CHILDREN_KEY % self.pk)
        # XXX: Should this have a depth limit?
        if self.parent_id:
            self.parent.invalidate()
        self._languages = None
        self._complete_slug = None
        self._content_dict = dict()

        placeholders = get_placeholders(self.get_template())

        p_names = [p.ctype for p in placeholders]
        if 'slug' not in p_names:
            p_names.append('slug')
        if 'title' not in p_names:
            p_names.append('title')

        from pages.managers import fake_page
        shared = [p for p in placeholders if p.shared]
        for share in shared:
            fake_page.invalidate(share.ctype)

        # delete content cache, frozen or not
        for name in p_names:
            # frozen
            cache.delete(
                PAGE_CONTENT_DICT_KEY %
                (self.pk, name, 1))
            # not frozen
            cache.delete(
                PAGE_CONTENT_DICT_KEY %
                (self.pk, name, 0))

        cache.delete(self.PAGE_URL_KEY % (self.pk))
429116
def delete(connection)
      xml = %(<EnginePoolDeleteRequest session-id="#{connection.session_id}">)
      xml << %(<EnginePool name="#{@name}" scope="#{@scope}" />)
      xml << '</EnginePoolDeleteRequest>'

      r = connection.execute(xml, '1.2')
      r.success
    end
532056
def delete(path, options = {}, &block)
      perform_request Net::HTTP::Delete, path, options, &block
    end
237053
private function softDelete(Page $page)
    {
        if ($page->isRoot()) {
            throw new BadRequestHttpException('Cannot remove root page of a site.');
        }

        $this->granted('DELETE', $page);
        $this->granted('EDIT', $page->getParent()); // user must have edit permission on parent

        if ($page->isOnline(true)) {
            $this->granted('PUBLISH', $page); // user must have publish permission on the page
        }

        $this->getPageRepository()->toTrash($page);
    }
522744
public function cleanDocumentHead()
    {
        remove_action('wp_head', 'feed_links_extra');
        remove_action('wp_head', 'feed_links');
        remove_action('wp_head', 'rsd_link');
        remove_action('wp_head', 'wlwmanifest_link');
        remove_action('wp_head', 'index_rel_link');
        remove_action('wp_head', 'parent_post_rel_link', 10);
        remove_action('wp_head', 'start_post_rel_link', 10);
        remove_action('wp_head', 'adjacent_posts_rel_link_wp_head', 10);
        remove_action('wp_head', 'wp_generator');
    }
226127
def destroy(self):
        
        logger.info("Destroying page: %s" % self)
        if self.doc.nb_pages <= 1:
            self.doc.destroy()
            return
        doc_pages = self.doc.pages[:]
        current_doc_nb_pages = self.doc.nb_pages
        paths = [
            self.__get_box_path(),
            self.__get_img_path(),
            self._get_thumb_path(),
        ]
        for path in paths:
            if self.fs.exists(path):
                self.fs.unlink(path)
        for page_nb in range(self.page_nb + 1, current_doc_nb_pages):
            page = doc_pages[page_nb]
            page.change_index(offset=-1)
758234
def delete(self):
        
        self.clear()
        if os.path.isfile(self._filename):
            os.unlink(self._filename)
        else:
            LOGGER.debug('Session file did not exist: %s', self._filename)
961027
public function delete_page( $params ) {

		$params = (object) $params;
		if ( isset( $params->uri ) ) {
			$params->name = $params->uri;
			unset( $params->uri );
		}
		if ( isset( $params->name ) ) {
			$params->name = trim( $params->name, '/' );
		}
		$params->type = 'page';

		return $this->delete_object( $params );
	}
1228530
def cleanup(site, stitch)

      files = stitch.all_files.map{ |f| File.absolute_path(f)}
      files.concat stitch.deleted

      if files.size > 0
        site.static_files.clone.each do |sf|
          if sf.kind_of?(Jekyll::StaticFile) and files.include? sf.path
            site.static_files.delete(sf)
          end
        end
      end
    end