This command is identical to its parent, but public rather than protected.
776095
public function runCommand(Command $command, InputInterface $input, OutputInterface $output) {
    return $this->doRunCommand($command, $input, $output);
  }
237489
def parent(version=None, include=None):
    '''
    
    '''
    parser = argparse.ArgumentParser(add_help=False)
    add_default_args(parser, version=version, include=include)
    return parser
718883
def parent=(parent)
      if @rank.nil?
        raise Taxonifi::NameError, "Parent of name can not be set if rank of child is not set." 
      end

      # TODO: ICZN class over-ride
      if parent.class != Taxonifi::Model::Name
        raise NameError, "Parent is not a Taxonifi::Model::Name."
      end

      if (RANKS.index(parent.rank) >= RANKS.index(self.rank))
        #  warn "WARNING:: Assigning parent to Name at same or lower rank than self (#{rank})."
        raise NameError, "Parent is same or lower rank than self (#{rank})."
      end

      @parent = parent
    end
1093772
def execute(self, processProtocol, command, env={},
                path=None, uid=None, gid=None, usePTY=0, childFDs=None):
        
        raise NotImplementedError()
999737
public UNode toUNode() {
        UNode rootNode = UNode.createMapNode("commands");
        for (String ownerName : m_cmdsByOwnerMap.keySet()) {
            Map<String, RESTCommand> ownerMap = m_cmdsByOwnerMap.get(ownerName);
            UNode ownerNode = rootNode.addMapNode(ownerName, "owner");
            for (String cmdName : ownerMap.keySet()) {
                RESTCommand cmd = ownerMap.get(cmdName);
                ownerNode.addChildNode(cmd.toDoc());
            }
        }
        return rootNode;
    }
760840
def cli(main, conf_dir=None, commands_dir=None):
    
    return Command(main, conf_dir=conf_dir, commands_dir=commands_dir)()
1175969
def cmd(commands, opts={})
      key_by = opts.delete(:key_by) || :instance_id
      results = {}
      threads = nodes.collect do |n|
        puts "result for #{n.instance_id} ==> n.ssh(#{commands.inspect}, #{opts.inspect})"
        Thread.new{ results[ n.send(key_by) ] = n.ssh(commands, opts) }
      end
      threads.each{ |aThread| aThread.join }
      results
    end
358867
def lock
      cmd = Xcode::Shell::Command.new "security"
      cmd << "lock-keychain"
      cmd << "\"#{@path}\""
      cmd.execute
    end
232333
def parent_machine
      current = parent
      current = current.parent while current && !current.is_a?(VM)
      current
    end
794161
def __redirect_stdio_emit(self, value):
        
        parent = self.parent()
        while parent is not None:
            try:
                parent.redirect_stdio.emit(value)
            except AttributeError:
                parent = parent.parent()
            else:
                break
294483
def is_public(self):
        """"""
        return isinstance(self._key, Public) and not isinstance(self._key, Private)
272180
def remove_private_obfuscation(self):
    
    classname = self.__class__.__name__
    attrlist = [attr for attr in dir(self) if attr.startswith('_' + classname + '__')]
    for attr in attrlist:
        method = getattr(self, attr)
        truename = attr.replace('_' + classname + '__', '__')
        setattr(self, truename, method)
73831
private static boolean sameAccess(int parentAccess, int childAccess) {
        return ((parentAccess & (Const.ACC_PUBLIC | Const.ACC_PROTECTED)) == (childAccess & (Const.ACC_PUBLIC | Const.ACC_PROTECTED)));
    }
987673
function process(parent, index, commands) {
    var cmd = commands[index],
        ret;

    switch (cmd.value[0].type) {
        case ConkittyTypes.TEMPLATE_NAME:
            ret = processCall(parent, false, cmd);
            break;

        case ConkittyTypes.COMMAND_NAME:
            switch (cmd.value[0].value) {
                case 'ATTR':
                    ret = processAttr(parent, true, cmd);
                    break;

                case 'CALL':
                    ret = processCall(parent, true, cmd, commands[index + 1]);
                    break;

                case 'CHOOSE':
                    ret = processChoose(parent, cmd);
                    break;

                case 'EACH':
                    ret = processEach(parent, cmd, commands[index + 1]);
                    break;

                case 'EXPOSE':
                    ret = processExpose(parent, cmd);
                    break;

                case 'JS':
                    ret = processJS(parent, cmd);
                    break;

                case 'MEM':
                    ret = processMem(parent, cmd);
                    break;

                case 'PAYLOAD':
                    ret = processPayload(parent, cmd);
                    break;

                case 'SET':
                    ret = processSet(parent, cmd);
                    break;

                case 'TEST':
                    ret = processTest(parent, cmd);
                    break;

                case 'TRIGGER':
                    ret = processTrigger(parent, cmd);
                    break;

                case 'WITH':
                    ret = processWith(parent, cmd, commands[index + 1]);
                    break;

                default:
                    throw new ConkittyErrors.InconsistentCommand(cmd.value[0]);
            }

            break;

        case ConkittyTypes.VARIABLE:
            ret = processVariable(parent, cmd);
            break;

        case ConkittyTypes.JAVASCRIPT:
            ret = processJavascript(parent, cmd);
            break;

        case ConkittyTypes.STRING:
            ret = processString(parent, cmd);
            break;

        case ConkittyTypes.CSS:
            ret = processElement(parent, cmd);
            break;

        case ConkittyTypes.ATTR:
            ret = processAttr(parent, false, cmd);
            break;

        case ConkittyTypes.INCLUDE:
            ret = processInclude(parent, cmd);
            break;

        case ConkittyTypes.NODE_APPENDER:
            ret = processAppender(parent, cmd);
            break;

        default:
            throw new ConkittyErrors.InconsistentCommand(cmd.value[0]);
    }

    return index + ret;
}
689994
public <T extends KubernetesCommand> T command(T command) {
		action.setCommand(command);
		return command;
	}
200035
def public(self, boolean):
        """"""
        if(boolean):
            r = self.flag({
                "flag": "make_public"
            })
        else:
            r = self.flag({
                "flag": "make_private"
            })

        return r
996567
def without_host_key_checking_linux
      tmpdir = ::Dir.mktmpdir
      ssh_cmd = ::File.join(tmpdir, 'ssh')

      ::File.open(ssh_cmd, 'w') do |cmd|
        cmd.puts "#!/bin/bash"
        cmd.puts "exec ssh -o StrictHostKeyChecking=no ${@}"
      end
      ::FileUtils.chmod(0700, ssh_cmd)

      old_env = ::ENV['GIT_SSH']
      ::ENV['GIT_SSH'] = ssh_cmd
      yield
    ensure
      ::FileUtils.rm_rf(tmpdir)
      ::ENV['GIT_SSH'] = old_env
    end