Parse the given actions as (row) object actions.

@param  array $actions Actions to resolve.
@return array
346721
protected function parseAsObjectActions(array $actions)
    {
        $objectActions = [];
        foreach ($actions as $action) {
            $action = $this->parseActionRenderables($action, true);

            if (isset($action['ident'])) {
                if ($action['ident'] === 'view' && !$this->isObjViewable()) {
                    $action['active'] = false;
                } elseif ($action['ident'] === 'create' && !$this->isObjCreatable()) {
                    $action['active'] = false;
                } elseif ($action['ident'] === 'edit' && !$this->isObjEditable()) {
                    $action['active'] = false;
                } elseif ($action['ident'] === 'delete' && !$this->isObjDeletable()) {
                    $action['active'] = false;
                }
            }

            if ($action['actions']) {
                $action['actions']    = $this->parseAsObjectActions($action['actions']);
                $action['hasActions'] = !!array_filter($action['actions'], function ($action) {
                    return $action['active'];
                });
            }

            $objectActions[] = $action;
        }

        return $objectActions;
    }
938291
protected function gatherTableMoves($actions)
    {
        collection($actions)
            ->filter(function ($action) {
                return $action instanceof DropTable
                    || $action instanceof RenameTable
                    || $action instanceof ChangePrimaryKey
                    || $action instanceof ChangeComment;
            })
            ->each(function ($action) {
                $table = $action->getTable();
                $name = $table->getName();

                if (!isset($this->tableMoves[$name])) {
                    $this->tableMoves[$name] = new AlterTable($table);
                }

                $this->tableMoves[$name]->addAction($action);
            });
    }
27126
protected function parseDocThrows( $matches )
	{
		$throws	= new ADT_PHP_Throws( trim( $matches[1] ) );
		if( isset( $matches[2] ) )
			$throws->setReason( trim( $matches[2] ) );
		return $throws;
	}
492559
public function parseResult($results)
    {
        $simpleDataTable = $results->getDataTable()->toSimpleObject();

        foreach ($simpleDataTable->cols as $col) {
            $cols[] = $col['label'];
        }

        foreach ($simpleDataTable->rows as $row) {
            foreach ($row['c'] as $key => $value) {
                $rowData[$cols[$key]] = $value['v'];
            }

            $rows[] = $rowData;

            unset($rowData);
        }

        return [
            'cols' => $cols,
            'rows' => $rows,
        ];
    }
831663
protected function getActionsAsArrays()
    {
        $actions = [];

        foreach ($this->getActions() as $action) {
            $actions[] = $action->toArray();
        }

        return $actions;
    }
1224339
protected function gatherIndexes($actions)
    {
        collection($actions)
            ->filter(function ($action) {
                return $action instanceof AddIndex
                    || $action instanceof DropIndex;
            })
            ->reject(function ($action) {
                // Indexes for new tables are created inline
                // so we don't wan't them here too
                return isset($this->tableCreates[$action->getTable()->getName()]);
            })
            ->each(function ($action) {
                $table = $action->getTable();
                $name = $table->getName();

                if (!isset($this->indexes[$name])) {
                    $this->indexes[$name] = new AlterTable($table);
                }

                $this->indexes[$name]->addAction($action);
            });
    }
1176348
protected function parseActionCssClasses($classes, $action = null, $renderer = null)
    {
        if ($renderer === null) {
            $renderer = $this->getActionRenderer();
        }

        if (is_string($classes)) {
            $classes = explode(' ', $classes);
        } elseif (!is_array($classes)) {
            $classes = [];
        }
        $classes[] = 'btn';
        $classes[] = 'btn-'.$action['actionType'];
        $classes[] = $this->jsActionPrefix().'-'.$action['ident'];

        return $classes;
    }
1061673
public function onPluginActionLinks(array $actions): array
    {
        if ($this->App->Config->§specs['§type'] !== 'plugin') {
            return $actions; // Not applicable.
        }
        if (($default_url = $this->defaultUrl())) { // See {@link defaultUrl()} below.
            $actions[] = '<a href="'.esc_url($default_url).'">'.__('Settings', 'wp-sharks-core').'</a>';
        }
        if (!$this->App->Config->§specs['§is_pro'] && !$this->App->Config->§specs['§is_elite'] && $this->App->Config->§specs['§has_pro']) {
            $actions[] = '<a href="'.esc_url($this->s::brandUrl('/', 'pro')).'" target="_blank">'.__('Pro Upgrade', 'wp-sharks-core').' <i class="sharkicon sharkicon-octi-tag"></i></a>';
        } elseif (!$this->App->Config->§specs['§is_elite'] && $this->App->Config->§specs['§has_elite']) {
            $actions[] = '<a href="'.esc_url($this->s::brandUrl('/', 'elite')).'" target="_blank">'.__('Elite Upgrade', 'wp-sharks-core').' <i class="sharkicon sharkicon-octi-tag"></i></a>';
        }
        if ($this->App->is_core) {
            $actions[] = '<a href="'.esc_url($this->s::coreUrl('/shop')).'" target="_blank">'.esc_html($this->App::CORE_CONTAINER_NAME).'™ <i class="sharkicon sharkicon-wp-sharks-fin"></i></a>';
        }
        return $actions;
    }
796997
public static function make($actions)
    {
        $instance = new static();

        if (array_key_exists(
            'whenInsert',
            $actions
        )) {
            $instance->setWhenInsert(ActionEntry::make($actions['whenInsert']));
        }

        if (array_key_exists(
            'whenUpdate',
            $actions
        )) {
            $instance->setWhenUpdate(ActionEntry::make($actions['whenUpdate']));
        }

        if (array_key_exists(
            'whenDelete',
            $actions
        )) {
            $instance->setWhenDelete(ActionEntry::make($actions['whenDelete']));
        }

        return $instance;
    }
95888
public function getExpandActions($actions)
    {
        $actions = (array) $actions;
        return array_flatten(array_map(function ($action) use ($actions) {
            return array_key_exists($action, $this->getAliasedActions()) ? [$action, $this->getExpandActions($this->getAliasedActions()[$action])] : $action;
        }, $actions));
    }
1148495
protected function row_actions($actions, $always_visible = false)
    {
        $action_count = count($actions);
        $i = 0;

        if (!$action_count) {
            return '';
        }

        $out = '<div class="' . ($always_visible ? 'row-actions-visible' : 'row-actions') . '">';

        foreach ($actions as $action => $link) {
            $i++;
            ($i == $action_count) ? $sep = '' : $sep = ' | ';
            $out .= "<span class='$action'>$link$sep</span>";
        }

        $out .= '</div>';

        return $out;
    }
1016458
public function objectActions()
    {
        $this->rawObjectActions();

        $objectActions = [];
        if (is_array($this->objectActions)) {
            $objectActions = $this->parseAsObjectActions($this->objectActions);
        }

        return $objectActions;
    }
711575
public function addActions(array $actions)
    {
        collect($actions)->each(function ($action) {
            $this->addAction($action);
        });

        return $this;
    }
611987
public function setListActions(array $actions)
    {
        foreach ($actions as $key => $action) {
            $this->addListAction($key, $action);
        }

        return $this;
    }
374465
protected function _actionIsEnabled($action)
    {
        $actions = $this->type['actions'];

        if (array_key_exists($action, $actions)) {
            return $actions[$action];
        }
        return true;
    }
1099384
public function normalizeAction($actions): array
    {
        $addNamespace = function ($action) {
            if ($action = ltrim($action, '\\')) {
                return $action;
            }

            return app()->getNamespace().'\\Http\\Controllers\\'.$action;
        };

        return array_map($addNamespace, $actions);
    }
52712
final private function parse_actions()
    {
        if (isset($this->actions) && \is_array($this->actions) && !empty($this->actions)) {
            $this->add_hooks($this->actions);
        }
    }