Try to formulate a path to view the handcart show page
507699
def handcart_show_path(handcart)
      if Handcart.handcart_show_path.present?
        # Load it straight from the config
        "/#{Handcart.handcart_show_path}/#{handcart.to_param}"
      else
        if Rails.application.routes.url_helpers.respond_to?("#{Handcart.handcart_class.model_name.singular}_path".to_sym)
          # Is there one already defined
          Rails.application.routes.url_helpers.send("#{Handcart.handcart_class.model_name.singular}_path", handcart.to_param)
        else
          # Shot in the dark
          "/#{Handcart.handcart_class.model_name.route_key}/#{handcart.to_param}"
        end
      end
    end
1058384
function chooseViewForRoute() {
            var allParams = addExtraParamsTo(params,
                layoutDelegate,
                serverRequest,
                serverResponse
            );

            return promisify(originalHandler).apply(router, allParams)
                .then(function(view) {
                    validateView(view);

                    return {
                        view: view,
                        reason: null,
                    };
                })
                .catch(function(reason) {
                    return {
                        view: null,
                        reason: reason
                    };
                });
        }
1164949
def showpath(path):
    """"""
    if logger.verbose:
        return os.path.abspath(path)
    else:
        path = os.path.relpath(path)
        if path.startswith(os.curdir + os.sep):
            path = path[len(os.curdir + os.sep):]
        return path
1211301
def _view(self, filepath, format):
        """"""
        methodnames = [
            '_view_%s_%s' % (format, backend.PLATFORM),
            '_view_%s' % backend.PLATFORM,
        ]
        for name in methodnames:
            view_method = getattr(self, name, None)
            if view_method is not None:
                break
        else:
            raise RuntimeError('%r has no built-in viewer support for %r '
                'on %r platform' % (self.__class__, format, backend.PLATFORM))
        view_method(filepath)
1311788
function open(path, flags, mode, callback) {
        resolvePath(path, function (err, path) {
            if (err) return callback(err);
            fs.open(path, flags, mode, function (err, fd) {
                if (err) return callback(err);
                fs.fstat(fd, function (err, stat) {
                    if (err) return callback(err);
                    callback(null, path, fd, stat);
                });
            });
        });
    }
1282869
public function show(self $_vinala_view = null)
    {
        if (is_null($_vinala_view)) {
            $_vinala_view = $this;
        }

        if ($_vinala_view->engine == 'atomium') {
            self::atomium($_vinala_view->path, $_vinala_view->data, $_vinala_view->nest);
        } elseif ($_vinala_view->engine == 'smarty') {
            Template::show($_vinala_view->path, $_vinala_view->data);
        } else {
            if (!is_null($_vinala_view->data)) {
                foreach ($_vinala_view->data as $_vinala_view_keys => $_vinala_view_values) {
                    $$_vinala_view_keys = $_vinala_view_values;
                }
            }

            include $_vinala_view->path;
        }
    }
341290
def path_helper(self, path, view, **kwargs):
        
        super(FlaskRestyPlugin, self).path_helper(
            path=path,
            view=view,
            **kwargs
        )

        resource = self.get_state().views[view]
        rule = self._rules[resource.rule]

        operations = defaultdict(Operation)
        view_instance = view()
        view_instance.spec_declaration(view, operations, self)

        # add path arguments
        parameters = []
        for arg in rule.arguments:
            parameters.append({
                'name': arg,
                'in': 'path',
                'required': True,
                'type': 'string',
            })
        if parameters:
            operations['parameters'] = parameters

        path.path = FlaskPlugin.flaskpath2openapi(resource.rule)
        path.operations = dict(**operations)
631346
def add_route(self, view: View, path: str, exact: bool = True) -> None:
        
        if path[0] != '/':
            path = '/' + path
        for route in self._routes:
            assert path != route.path, 'Cannot use the same path twice'
        self._routes.append(Route(view=view, path=path, exact=exact))

        self.app.add_url_rule(
            path, path[1:], lambda: render_template('bowtie.html', title=self.title)
        )
963911
def ticket_form_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/ticket_forms/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
683478
def route_index_page(params)

      if defined?(params[:search]) && !params[:search].blank?

        # make the content avalible to the view
        gloalize Post.where("(post_title LIKE :p or post_slug LIKE :p2 or post_content LIKE :p3) AND (post_type != 'autosave') AND (post_date <= CURRENT_TIMESTAMP)", { p: "%#{params[:search]}%", p2: "%#{params[:search]}%", p3: "%#{params[:search]}%" }).page(params[:page]).per(Setting.get('pagination_per_fe'))

        # add breadcrumbs to the hash
        add_breadcrumb I18n.t("generic.home"), :root_path, :title => I18n.t("generic.home")
        add_breadcrumb I18n.t("generic.search"), "/"

        # template Hierarchy
        do_hierarchy_templating('search')

      else

        @content = Post.find_by_id(Setting.get('home_page'))
        render_404 and return if @content.blank? || @content.post_status != 'Published'
        # make the content avalible to the view
        gloalize @content
        render_template 'home'

      end

    end
54130
def show_page_path_params(page, optional_params = {})
      raise ArgumentError, 'Page is nil' if page.nil?
      url_params = {urlname: page.urlname}.update(optional_params)
      prefix_locale? ? url_params.update(locale: page.language_code) : url_params
    end
16652
def for_path(path, revision=nil, cmd_options={})
      revision ||= 'tip'
      build do
        hg(["blame ? -ucl -r ?", path, revision], cmd_options)
      end
    end
28205
def path(name):
    """"""
    try:
        coll = Collection.query.filter(Collection.name == name).one()
        tr = LeftAligned(
            traverse=CollTraversalPathToRoot(coll.path_to_root().all()))
        click.echo(tr(coll))
    except NoResultFound:
        raise click.UsageError('Collection {0} not found'.format(name))
251535
def code_browse path
      dr = ruby_renderer
      view(path, :close_key => 'q', :title => $0) do |t|
        t.renderer  dr
        t.bind_key([?\\,?\\,?o],'choose file') { 
          str = choose_file "**/*"
          if str and str != ""
            t.add_content str
            t.buffer_last
          else
            alert "nothing chosen"
          end
        }
      end
  end
1184618
function getPath(path, callback) {
  fs.lstat(path, function(err, stats) {
    if(err) return callback(err);

    // Check if it's a link
    if(stats.isSymbolicLink()) fs.readlink(path, callback);

    callback(err, path);
  });
}
22572
def finding_path(cls, organization, source, finding):
        """"""
        return google.api_core.path_template.expand(
            "organizations/{organization}/sources/{source}/findings/{finding}",
            organization=organization,
            source=source,
            finding=finding,
        )
572412
function(e) {
      var t = this,
          item = $(e.currentTarget),
          id = item.attr('data-id'),
          path = item.attr('data-path');

      // Process a tour selection
      if ($(e.currentTarget).parents('.nm-sb-tours').length) {
        UI.pageView.runTour(path);
        return;
      }

      // Process a page selection
      UI.pageView.navigateTo(path);
    }