Fills the block directives by compiling the memoized files.
161784
public function compileFiles()
    {
        foreach ($this->files as $file) {
            $activeConfig = $this->parser->setConfigFile($file)->getActiveConfig();
            $this->add($activeConfig);
        }

        return $this;
    }
522934
private function directives() : void
  {
    Using::$engine      = config('view.engine');
    Using::$views       = config('app.dir') . config('view.views');

    Partial::$views     = config('app.dir') . config('view.views');
    Partial::$extension = config('view.extension');
  }
1163876
protected function replaceDocblockTags()
    {
        $this->out('Replacing Docblock');

        $files = new RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator(
                WINDWALKER_ROOT . '/src',
                \FilesystemIterator::SKIP_DOTS
            )
        );

        /** @var \SplFileInfo $file */
        foreach ($files as $file) {
            if ($file->isDir() || $file->getExtension() != 'php') {
                continue;
            }

            $content = file_get_contents($file->getPathname());

            $content = str_replace(
                ['{DEPLOY_VERSION}', '__DEPLOY_VERSION__', '__LICENSE__', '{ORGANIZATION}'],
                [$this->tag, $this->tag, 'LGPL-2.0-or-later', 'Asikart'],
                $content
            );

            file_put_contents($file->getPathname(), $content);

            $this->out('[Replace Docblock] ' . $file->getPathname());
        }

        $this->exec('git checkout master');
        $this->exec(sprintf('git commit -am "Prepare for %s release."', $this->tag));
        $this->exec('git push origin master');
    }
182601
private function populateMimeTypes(): void
    {
        if (null !== $this->mimeTypes) {
            return;
        }

        $this->mimeTypes = [];
        foreach ($this->formats as $format => $mimeTypes) {
            foreach ($mimeTypes as $mimeType) {
                $this->mimeTypes[$mimeType] = $format;
            }
        }
    }
146112
function(file) {
      var sections = file.contents.toString().split(END_REG);

      var blocks = [],
        files = [];

      var self = this;

      sections.forEach(function(s) {
        if (s.match(START_REG)) {
          // s[0] html code
          // s[1] string 'css' or 'js'
          // s[2] string dest url
          // s[3] tags of link or script
          s = s.split(START_REG);
          blocks.push(s[0]);
          switch (s[1]) {
            case 'css':
              blocks.push('<link rel="stylesheet" href="' + s[2] + '">');
              break;
            case 'js':
              blocks.push('<script src="' + s[2] + '"></script>');
              break;
            default:
              throw new gutil.PluginError('gulp-htmlbuild', 'only build:css build:js accept\n');
          }
          var paths = self.matchContentPaths(s[1] === 'css' ? CSSFILE_REG : JSFILE_REG, s[3]);
          var source = concatSource(paths);
          files.push({
            type: s[1],
            dest: resolveSrc(s[2], self.filedir),
            source: source
          });
        } else {
          blocks.push(s);
        }
      });

      return {
        blocks: blocks,
        files: files
      }
    }
492563
function(ctx, blocks) {
                this.ctx = ctx;
                // ... this.blocks = {xxx: []}
                this.blocks = {};
                this.exported = [];

                for (var name in blocks) {
                    this.addBlock(name, blocks[name]);
                }
            }
809116
def _fill_cache(self):
        """"""
        for irow in range(len(self._table)):
            file_handle = self._make_file_handle(irow)
            self._cache[file_handle.path] = file_handle
820492
def _build_block_context(template, context):
    """"""

    # Ensure there's a BlockContext before rendering. This allows blocks in
    # ExtendsNodes to be found by sub-templates (allowing {{ block.super }} and
    # overriding sub-blocks to work).
    if BLOCK_CONTEXT_KEY not in context.render_context:
        context.render_context[BLOCK_CONTEXT_KEY] = BlockContext()
    block_context = context.render_context[BLOCK_CONTEXT_KEY]

    for node in template.nodelist:
        if isinstance(node, ExtendsNode):
            compiled_parent = node.get_parent(context)

            # Add the parent node's blocks to the context. (This ends up being
            # similar logic to ExtendsNode.render(), where we're adding the
            # parent's blocks to the context so a child can find them.)
            block_context.add_blocks(
                {n.name: n for n in compiled_parent.nodelist.get_nodes_by_type(BlockNode)})

            _build_block_context(compiled_parent, context)
            return compiled_parent

        # The ExtendsNode has to be the first non-text node.
        if not isinstance(node, TextNode):
            break
656348
void copyBlocksTo(RegularFile target, int count) {
    int start = blockCount - count;
    int targetEnd = target.blockCount + count;
    target.expandIfNecessary(targetEnd);

    System.arraycopy(this.blocks, start, target.blocks, target.blockCount, count);
    target.blockCount = targetEnd;
  }
29668
void startBlockImpl( String[] selectors ) {
        for( int i=0; i<selectors.length; i++ ) {
            if( i > 0 ) {
                output.append( ',' );
                newline();
            }
            insets();
            append( selectors[i] );
        }
        space();
        output.append( '{' );
        newline();
        incInsets();
    }
1171085
private void fillDataStructures() {
        final ITreeData treeData = mRtx.getNode();
        mInOrder.put(treeData, true);
        mDescendants.put(treeData, 1L);
    }
258129
def populate_files_from_append_templates
        @append_templates.each do |x|
          new_name = x.sub(/_([lL]?)\._{1}/, '')
          FileUtils.touch(FileUtils.join_paths(@install_path, @project_name, new_name))
          FileUtils.append_to_end_of_file(FileUtils.join_paths(@template_path, x), FileUtils.join_paths(@install_path, @project_name, new_name), JumpStart::Base.remove_last_line?(x))
        end
      end
1132743
private void fillMissingDurations() {
        long[] extendedArray = new long[buildNumbers.length];
        Arrays.fill(extendedArray, -1);
        System.arraycopy(durations, 0, extendedArray, buildNumbers.length - durations.length, durations.length);
        durations = extendedArray;
    }
404488
private void processFiles() {
        String[] fileArgs = getOptionValues(INFILE_SHORT_OPT);
        final List<File> files = new ArrayList<File>(fileArgs.length);
        for (final String fileArg : fileArgs) {
            File file = new File(fileArg);
            if (!file.canRead()) {
                error(INPUT_FILE_UNREADABLE + file);
            } else {
                files.add(file);
            }
        }

        if (files.size() == 0) {
            error(NO_DOCUMENT_FILES);
            failUsage();
        }

        // Create the directory artifact or fail
        artifactPath = createDirectoryArtifact(outputDirectory, DIR_ARTIFACT);
        processFiles(files.toArray(new File[0]));
    }
866354
public void compile() {
        // Treat media queries as "normal" sections as they are supported by CSS
        sections.addAll(mediaQueries.values());
        for (Section section : new ArrayList<Section>(sections)) {
            compileSection(section);
        }

        // Delete empty selectors
        sections.removeIf(section -> section.getSubSections().isEmpty() && section.getAttributes().isEmpty());
    }
870045
void mergeContiguousRegions( Collection<AbstractBlock> blocks ) {

		AbstractIgnorableInstruction initialInstr = null;
		List<AbstractBlock> toRemove = new ArrayList<> ();
		StringBuilder sb = new StringBuilder();

		// We only merge comments and blank regions to reduce their number
		for( AbstractBlock block : blocks ) {
			if( initialInstr == null ) {

				if( block.getInstructionType() == AbstractBlock.COMMENT
						|| block.getInstructionType() == AbstractBlock.BLANK ) {

					AbstractIgnorableInstruction currentInstr = (AbstractIgnorableInstruction) block;
					initialInstr = currentInstr;
					sb = new StringBuilder( currentInstr.getContent());
				}

			} else if( initialInstr.getInstructionType() == block.getInstructionType()) {
				toRemove.add( block );
				sb.append( System.getProperty( "line.separator" ));
				sb.append(((AbstractIgnorableInstruction) block).getContent());

			} else {
				initialInstr.setContent( sb.toString());
				initialInstr = null;
			}
		}

		// Remove the blocks that have been merged
		blocks.removeAll( toRemove );

		// In a second time, we can reduce facets and components too
		for( AbstractBlock block : blocks ) {
			if( block.getInstructionType() == AbstractBlock.COMPONENT
					|| block.getInstructionType() == AbstractBlock.FACET )
				mergeContiguousRegions(((AbstractBlockHolder) block).getInnerBlocks());
		}
	}
1032958
protected function fillScopes(){

        if($this->scopes !== null){
            return;
        }

        $this->scopes = [];

        foreach($this->treeModel->rootNodes() as $rootNode){

            $this->addToScopes($this->node2Scope($rootNode));


        }

        foreach ($this->manualScopes as $scope) {
            $this->addToScopes($scope);
        }

    }