Returns subscriptions_path for the target

 @param [Object] target Target instance
 @param [Hash] params Request parameters
 @return [String] subscriptions_path for the target
 @todo Needs any other better implementation
504409
def subscriptions_path_for(target, params = {})
      options = params.dup
      options.delete(:devise_default_routes) ?
        send("#{routing_scope(options)}subscriptions_path", options) :
        send("#{routing_scope(options)}#{target.to_resource_name}_subscriptions_path", target, options)
    end
1319281
def user_organization_subscriptions(self, user_id, **kwargs):
        ""
        api_path = "/api/v2/users/{user_id}/organization_subscriptions.json"
        api_path = api_path.format(user_id=user_id)
        return self.call(api_path, **kwargs)
1226605
def get_symbolized_path(request)
      request_path = (request.env['REQUEST_URI'] || request.path).dup
      request_params =
        request.env['action_dispatch.request.parameters'] ||
        request.env['rack.request.form_hash'] ||
        request.env['rack.request.query_hash']

      if request_params
        request_params
          .except(*EXCLUDE_PARAMS)
          .select { |_, value| value.is_a?(String) }
          .each { |key, value| request_path.sub!("/#{value}", "/:#{key}") if value.to_s != '' }
      end

      request_path.freeze
    end
1009692
function(subscription_id) {
    var params = {
      client_id:     this._credentials.client_id,
      client_secret: this._credentials.client_secret
    };
    if (subscription_id==='users') {
      params.object = 'user';
    } else if (subscription_id==='all') {
      params.object = 'all';
    } else {
      params.id = subscription_id;
    }
    return params;
  }
584308
async def _get_subscriptions(self) -> Tuple[Set[Text], Text]:
        

        url, params = self._get_subscriptions_endpoint()

        get = self.session.get(url, params=params)

        async with get as r:
            await self._handle_fb_response(r)
            data = await r.json()

            for scope in data['data']:
                if scope['object'] == 'page':
                    return (
                        set(x['name'] for x in scope['fields']),
                        scope['callback_url'],
                    )

        return set(), ''
61154
def url_for(params)
      host_with_port = host || location.host
      host_with_port += ":#{port}" if port && port != 80
      scheme = scheme || location.scheme

      unless RUBY_PLATFORM == 'opal'
        # lazy load routes and views on the server
        if !@router && @routes_loader
          # Load the templates
          @routes_loader.call
        end
      end

      path, params = @router.params_to_url(params)

      if path == nil
        raise "No route matched, make sure you have the base route defined last: `client '/', {}`"
      end

      new_url    = "#{scheme}://#{host_with_port}#{path.chomp('/')}"

      # Add query params
      params_str = ''
      unless params.empty?
        query_parts = []
        nested_params_hash(params).each_pair do |key, value|
          # remove the _ from the front
          value = Volt::Parsing.encodeURI(value)
          query_parts << "#{key}=#{value}"
        end

        if query_parts.size > 0
          query = query_parts.join('&')
          new_url += "?#{query}"
        end
      end

      # Add fragment
      frag    = fragment
      new_url += '#' + frag if frag.present?

      new_url
    end
428725
def subscription_path(cls, project, incident, subscription):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/incidents/{incident}/subscriptions/{subscription}",
            project=project,
            incident=incident,
            subscription=subscription,
        )
993805
def _get(self, target, alias):
        
        if target not in self._aliases:
            return
        return self._aliases[target].get(alias)
71586
def _path(action=nil)
      # Use the absolute path if present, otherwise get the relative path
      pre_action_paths =
        if defined?(self.class::ABSOLUTE_PATH)
          [self.class::ABSOLUTE_PATH]
        else
          _path_array
        end
      # Join it with the action
      paths = pre_action_paths + [action]
      # Strip out empty elements
      paths = paths.map(&:to_s).reject(&:empty?)
      "/#{paths.join('/')}"
    end
46052
def get_subscriptions(self):
        
        return github.PaginatedList.PaginatedList(
            github.Repository.Repository,
            self._requester,
            self.url + "/subscriptions",
            None
        )
1347352
public Subscription get( Subscription subscription ) {
    return RestfulUtils.show( SubscriptionService.PATH, subscription, Subscription.class, super.httpClient );
  }
1268646
def target_named(target_name)
      return target_name if target_name.is_a?(Epuber::Book::Target)

      flat_all_targets.find do |target|
        target.name == target_name || target.name.to_s == target_name.to_s
      end
    end
1216893
function subCreate (req) {
  return [ req.params.service + '/' + req.params.subresources, req.body ];
}
640987
def community_post_subscription_show(self, post_id, id, **kwargs):
        ""
        api_path = "/api/v2/community/posts/{post_id}/subscriptions/{id}.json"
        api_path = api_path.format(post_id=post_id, id=id)
        return self.call(api_path, **kwargs)
885845
@SuppressWarnings("unchecked")
  public String path(T target, Object... params) {
    if (params.length == 0) return path(target, Collections.emptyMap());

    if (params.length == 1 && params[0] instanceof Map<?, ?>) return pathMap(target, (Map<Object, Object>) params[0]);

    if (params.length % 2 == 1) throw new RuntimeException("Missing value for param: " + params[params.length - 1]);

    final Map<Object, Object> map = new HashMap<Object, Object>();
    for (int i = 0; i < params.length; i += 2) {
      final String key   = params[i].toString();
      final String value = params[i + 1].toString();
      map.put(key, value);
    }
    return pathMap(target, map);
  }
321361
def get_target(cls, scheme, path, fragment, username,
                   password, hostname, port, query, **kwargs):
        
        raise NotImplementedError("get_target must be overridden")
1083570
def organization_subscription_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/organization_subscriptions/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)