Checks if undefined-step snippets are not provided.

    EXAMPLE:
        Then undefined-step snippets should not exist for:
            | Step |
            | When an known step is used |
            | Then another known step is used |
518033
def step_undefined_step_snippets_should_not_exist_for_table(context):
    
    assert context.table, "REQUIRES: table"
    for row in context.table.rows:
        step = row["Step"]
        step_undefined_step_snippet_should_not_exist_for(context, step)
177243
def undefined_entries(self) -> Set[str]:
        
        return as_set([[d for d in self.dependencies(k) if d not in self.grammarelts]
                       for k in self.grammarelts.keys()])
109871
private function generateSnippets()
    {
        if ($this->snippetsGenerated) {
            return null;
        }

        $snippetsSet = array();
        foreach ($this->undefinedSteps as $i => $undefinedStep) {
            $snippet = $this->generateSnippet($undefinedStep->getEnvironment(), $undefinedStep->getStep());

            if (!$snippet) {
                continue;
            }

            if (!isset($snippetsSet[$snippet->getHash()])) {
                $snippetsSet[$snippet->getHash()] = array();
            }

            $snippetsSet[$snippet->getHash()][] = $snippet;
            unset($this->undefinedSteps[$i]);
        }

        $this->snippets = array_values(
            array_map(
                function (array $snippets) {
                    return new AggregateSnippet($snippets);
                },
                $snippetsSet
            )
        );
        $this->undefinedSteps = array_values($this->undefinedSteps);
        $this->snippetsGenerated = true;
    }
904217
function hasProblematicComments(node, sourceCode) {
  return (
    hasCommentBefore(node, sourceCode) ||
    hasCommentAfter(node, sourceCode) ||
    hasCommentInsideNonSpecifiers(node, sourceCode)
  )
}
1359953
def check(name = @current_step_name, &block)
      raise "No step name" unless name
      @current_step_name ||= name
      checks << CheckBlock.new("progression_name", name, &block)

      define_method("#{name}?") do
        check = checks.find { |s| s.name == name }
        !! check.run(self)
      end
    end
820911
def possibly_include_hidden?
      return @possibly_include_hidden if defined?(@possibly_include_hidden)

      @possibly_include_hidden = patterns_to_include.any? do |s|
        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
      end
    end
1323077
function hasExample ({ optional, example, details } = {}) {
  if (optional || example !== undefined) {
    return true;
  }

  if (details !== undefined) {
    const values = Object.keys(details).map((key) => details[key]);

    return values.every(hasExample);
  }

  return false;
}
1102733
def undefine(self):
        
        if lib.EnvUndeftemplate(self._env, self._tpl) != 1:
            raise CLIPSError(self._env)
624378
def snippets(self):
        ''''''
        return [strip_suffix(f, '.yaml') for f in self._stripped_files if self._snippets_pattern.match(f)]
906767
private String isNotNullStep(Step<?, ?> currentStep) {
        if (currentStep instanceof TraversalFilterStep<?>) {
            TraversalFilterStep<?> tfs = (TraversalFilterStep<?>) currentStep;
            List<?> c = tfs.getLocalChildren();
            if (c != null && c.size() == 1) {
                Traversal.Admin<?, ?> a = (Traversal.Admin<?, ?>) c.iterator().next();
                Step<?, ?> s = a.getEndStep();
                if (a.getSteps().size() == 1 && s instanceof PropertiesStep<?>) {
                    PropertiesStep<?> ps = (PropertiesStep<?>) s;
                    String[] keys = ps.getPropertyKeys();
                    if (keys != null && keys.length == 1) {
                        return keys[0];
                    }
                }
            }
        }
        return null;
    }
860914
function NeverImplemented(message, code_id) {
    Error.call(this);
    this.message = message || "never will be implemented";
    this.code_id = code_id || null;
    this.statusCode = 501;
}
802249
def report_unused_steps
      # Remove any unused_steps that were in common modules and used
      # in another feature
      used_steps.each { |location| unused_steps.delete location }
      unused_steps.each do |location, name|
        puts "\n" + "Unused step: #{location} ".colorize(:yellow) +
             "'#{name}'".colorize(:light_yellow)
      end
    end
410486
def report_missing_steps(steps)
      puts "\nMissing steps:".colorize(:light_cyan)
      steps.each do |step|
        puts Generators::StepGenerator.new(step).generate.gsub(/^/, '  ')
          .colorize(:cyan)
      end
    end
605344
def _is_undefok(arg, undefok_names):
  """"""
  if not arg.startswith('-'):
    return False
  if arg.startswith('--'):
    arg_without_dash = arg[2:]
  else:
    arg_without_dash = arg[1:]
  if '=' in arg_without_dash:
    name, _ = arg_without_dash.split('=', 1)
  else:
    name = arg_without_dash
  if name in undefok_names:
    return True
  return False
1090486
def check_missing_references(client):
    """"""
    from renku.models.refs import LinkReference

    missing = [
        ref for ref in LinkReference.iter_items(client)
        if not ref.reference.exists()
    ]

    if not missing:
        return True

    click.secho(
        WARNING + 'There are missing references.'
        '\n  (use "git rm <name>" to clean them)\n\n\t' + '\n\t  '.join(
            click.style(str(ref.path), fg='yellow') + ' -> ' +
            click.style(str(ref.reference), fg='red') for ref in missing
        ) + '\n'
    )
    return False
1208236
def step_table_made(self):
        """"""
        try:
            empty = self.step_table.empty
        except AttributeError:
            empty = True
        return not empty
1064721
function Snippets(options) {
  this.options = options || {};
  this.store = store(this.options);

  this.snippets = {};
  this.presets = {};
  this.cache = {};
  this.cache.data = {};

  var FetchFiles = lazy.FetchFiles();
  this.downloader = new FetchFiles(this.options);
  this.presets = this.downloader.presets;

  if (typeof this.options.templates === 'object') {
    this.visit('set', this.options.templates);
  }
}