id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
151,800 | ulule/limiter | options.go | WithIPv6Mask | func WithIPv6Mask(mask net.IPMask) Option {
return func(o *Options) {
o.IPv6Mask = mask
}
} | go | func WithIPv6Mask(mask net.IPMask) Option {
return func(o *Options) {
o.IPv6Mask = mask
}
} | [
"func",
"WithIPv6Mask",
"(",
"mask",
"net",
".",
"IPMask",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Options",
")",
"{",
"o",
".",
"IPv6Mask",
"=",
"mask",
"\n",
"}",
"\n",
"}"
] | // WithIPv6Mask will configure the limiter to use given mask for IPv6 address. | [
"WithIPv6Mask",
"will",
"configure",
"the",
"limiter",
"to",
"use",
"given",
"mask",
"for",
"IPv6",
"address",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/options.go#L28-L32 |
151,801 | ulule/limiter | drivers/middleware/stdlib/options.go | DefaultErrorHandler | func DefaultErrorHandler(w http.ResponseWriter, r *http.Request, err error) {
panic(err)
} | go | func DefaultErrorHandler(w http.ResponseWriter, r *http.Request, err error) {
panic(err)
} | [
"func",
"DefaultErrorHandler",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"err",
"error",
")",
"{",
"panic",
"(",
"err",
")",
"\n",
"}"
] | // DefaultErrorHandler is the default ErrorHandler used by a new Middleware. | [
"DefaultErrorHandler",
"is",
"the",
"default",
"ErrorHandler",
"used",
"by",
"a",
"new",
"Middleware",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/middleware/stdlib/options.go#L29-L31 |
151,802 | ulule/limiter | drivers/middleware/stdlib/options.go | DefaultLimitReachedHandler | func DefaultLimitReachedHandler(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Limit exceeded", http.StatusTooManyRequests)
} | go | func DefaultLimitReachedHandler(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Limit exceeded", http.StatusTooManyRequests)
} | [
"func",
"DefaultLimitReachedHandler",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusTooManyRequests",
")",
"\n",
"}"
] | // DefaultLimitReachedHandler is the default LimitReachedHandler used by a new Middleware. | [
"DefaultLimitReachedHandler",
"is",
"the",
"default",
"LimitReachedHandler",
"used",
"by",
"a",
"new",
"Middleware",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/middleware/stdlib/options.go#L44-L46 |
151,803 | ulule/limiter | drivers/store/redis/store.go | NewStore | func NewStore(client Client) (limiter.Store, error) {
return NewStoreWithOptions(client, limiter.StoreOptions{
Prefix: limiter.DefaultPrefix,
CleanUpInterval: limiter.DefaultCleanUpInterval,
MaxRetry: limiter.DefaultMaxRetry,
})
} | go | func NewStore(client Client) (limiter.Store, error) {
return NewStoreWithOptions(client, limiter.StoreOptions{
Prefix: limiter.DefaultPrefix,
CleanUpInterval: limiter.DefaultCleanUpInterval,
MaxRetry: limiter.DefaultMaxRetry,
})
} | [
"func",
"NewStore",
"(",
"client",
"Client",
")",
"(",
"limiter",
".",
"Store",
",",
"error",
")",
"{",
"return",
"NewStoreWithOptions",
"(",
"client",
",",
"limiter",
".",
"StoreOptions",
"{",
"Prefix",
":",
"limiter",
".",
"DefaultPrefix",
",",
"CleanUpInterval",
":",
"limiter",
".",
"DefaultCleanUpInterval",
",",
"MaxRetry",
":",
"limiter",
".",
"DefaultMaxRetry",
",",
"}",
")",
"\n",
"}"
] | // NewStore returns an instance of redis store with defaults. | [
"NewStore",
"returns",
"an",
"instance",
"of",
"redis",
"store",
"with",
"defaults",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/redis/store.go#L37-L43 |
151,804 | ulule/limiter | drivers/store/redis/store.go | NewStoreWithOptions | func NewStoreWithOptions(client Client, options limiter.StoreOptions) (limiter.Store, error) {
store := &Store{
client: client,
Prefix: options.Prefix,
MaxRetry: options.MaxRetry,
}
if store.MaxRetry <= 0 {
store.MaxRetry = 1
}
_, err := store.ping()
if err != nil {
return nil, err
}
return store, nil
} | go | func NewStoreWithOptions(client Client, options limiter.StoreOptions) (limiter.Store, error) {
store := &Store{
client: client,
Prefix: options.Prefix,
MaxRetry: options.MaxRetry,
}
if store.MaxRetry <= 0 {
store.MaxRetry = 1
}
_, err := store.ping()
if err != nil {
return nil, err
}
return store, nil
} | [
"func",
"NewStoreWithOptions",
"(",
"client",
"Client",
",",
"options",
"limiter",
".",
"StoreOptions",
")",
"(",
"limiter",
".",
"Store",
",",
"error",
")",
"{",
"store",
":=",
"&",
"Store",
"{",
"client",
":",
"client",
",",
"Prefix",
":",
"options",
".",
"Prefix",
",",
"MaxRetry",
":",
"options",
".",
"MaxRetry",
",",
"}",
"\n\n",
"if",
"store",
".",
"MaxRetry",
"<=",
"0",
"{",
"store",
".",
"MaxRetry",
"=",
"1",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"store",
".",
"ping",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"store",
",",
"nil",
"\n",
"}"
] | // NewStoreWithOptions returns an instance of redis store with options. | [
"NewStoreWithOptions",
"returns",
"an",
"instance",
"of",
"redis",
"store",
"with",
"options",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/redis/store.go#L46-L63 |
151,805 | ulule/limiter | drivers/store/redis/store.go | peekValue | func peekValue(rtx *libredis.Tx, key string) (int64, time.Duration, error) {
pipe := rtx.Pipeline()
value := pipe.Get(key)
expire := pipe.PTTL(key)
_, err := pipe.Exec()
if err != nil && err != libredis.Nil {
return 0, 0, err
}
count, err := value.Int64()
if err != nil && err != libredis.Nil {
return 0, 0, err
}
ttl, err := expire.Result()
if err != nil {
return 0, 0, err
}
return count, ttl, nil
} | go | func peekValue(rtx *libredis.Tx, key string) (int64, time.Duration, error) {
pipe := rtx.Pipeline()
value := pipe.Get(key)
expire := pipe.PTTL(key)
_, err := pipe.Exec()
if err != nil && err != libredis.Nil {
return 0, 0, err
}
count, err := value.Int64()
if err != nil && err != libredis.Nil {
return 0, 0, err
}
ttl, err := expire.Result()
if err != nil {
return 0, 0, err
}
return count, ttl, nil
} | [
"func",
"peekValue",
"(",
"rtx",
"*",
"libredis",
".",
"Tx",
",",
"key",
"string",
")",
"(",
"int64",
",",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"pipe",
":=",
"rtx",
".",
"Pipeline",
"(",
")",
"\n",
"value",
":=",
"pipe",
".",
"Get",
"(",
"key",
")",
"\n",
"expire",
":=",
"pipe",
".",
"PTTL",
"(",
"key",
")",
"\n\n",
"_",
",",
"err",
":=",
"pipe",
".",
"Exec",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"libredis",
".",
"Nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"count",
",",
"err",
":=",
"value",
".",
"Int64",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"libredis",
".",
"Nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"ttl",
",",
"err",
":=",
"expire",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"count",
",",
"ttl",
",",
"nil",
"\n",
"}"
] | // peekValue will retrieve the counter and its expiration for given key. | [
"peekValue",
"will",
"retrieve",
"the",
"counter",
"and",
"its",
"expiration",
"for",
"given",
"key",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/redis/store.go#L149-L170 |
151,806 | ulule/limiter | drivers/store/redis/store.go | setValue | func setValue(rtx *libredis.Tx, key string, expiration time.Duration) (bool, error) {
value := rtx.SetNX(key, 1, expiration)
created, err := value.Result()
if err != nil {
return false, err
}
return created, nil
} | go | func setValue(rtx *libredis.Tx, key string, expiration time.Duration) (bool, error) {
value := rtx.SetNX(key, 1, expiration)
created, err := value.Result()
if err != nil {
return false, err
}
return created, nil
} | [
"func",
"setValue",
"(",
"rtx",
"*",
"libredis",
".",
"Tx",
",",
"key",
"string",
",",
"expiration",
"time",
".",
"Duration",
")",
"(",
"bool",
",",
"error",
")",
"{",
"value",
":=",
"rtx",
".",
"SetNX",
"(",
"key",
",",
"1",
",",
"expiration",
")",
"\n\n",
"created",
",",
"err",
":=",
"value",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"created",
",",
"nil",
"\n",
"}"
] | // setValue will try to initialize a new counter if given key doesn't exists. | [
"setValue",
"will",
"try",
"to",
"initialize",
"a",
"new",
"counter",
"if",
"given",
"key",
"doesn",
"t",
"exists",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/redis/store.go#L184-L193 |
151,807 | ulule/limiter | drivers/store/redis/store.go | updateValue | func updateValue(rtx *libredis.Tx, key string, expiration time.Duration) (int64, time.Duration, error) {
pipe := rtx.Pipeline()
value := pipe.Incr(key)
expire := pipe.PTTL(key)
_, err := pipe.Exec()
if err != nil {
return 0, 0, err
}
count, err := value.Result()
if err != nil {
return 0, 0, err
}
ttl, err := expire.Result()
if err != nil {
return 0, 0, err
}
// If ttl is -1ms, we have to define key expiration.
// PTTL return values changed as of Redis 2.8
// Now the command returns -2ms if the key does not exist, and -1ms if the key exists, but there is no expiry set
// We shouldn't try to set an expiry on a key that doesn't exist
if ttl == (-1 * time.Millisecond) {
expire := rtx.Expire(key, expiration)
ok, err := expire.Result()
if err != nil {
return count, ttl, err
}
if !ok {
return count, ttl, errors.New("cannot configure timeout on key")
}
}
return count, ttl, nil
} | go | func updateValue(rtx *libredis.Tx, key string, expiration time.Duration) (int64, time.Duration, error) {
pipe := rtx.Pipeline()
value := pipe.Incr(key)
expire := pipe.PTTL(key)
_, err := pipe.Exec()
if err != nil {
return 0, 0, err
}
count, err := value.Result()
if err != nil {
return 0, 0, err
}
ttl, err := expire.Result()
if err != nil {
return 0, 0, err
}
// If ttl is -1ms, we have to define key expiration.
// PTTL return values changed as of Redis 2.8
// Now the command returns -2ms if the key does not exist, and -1ms if the key exists, but there is no expiry set
// We shouldn't try to set an expiry on a key that doesn't exist
if ttl == (-1 * time.Millisecond) {
expire := rtx.Expire(key, expiration)
ok, err := expire.Result()
if err != nil {
return count, ttl, err
}
if !ok {
return count, ttl, errors.New("cannot configure timeout on key")
}
}
return count, ttl, nil
} | [
"func",
"updateValue",
"(",
"rtx",
"*",
"libredis",
".",
"Tx",
",",
"key",
"string",
",",
"expiration",
"time",
".",
"Duration",
")",
"(",
"int64",
",",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"pipe",
":=",
"rtx",
".",
"Pipeline",
"(",
")",
"\n",
"value",
":=",
"pipe",
".",
"Incr",
"(",
"key",
")",
"\n",
"expire",
":=",
"pipe",
".",
"PTTL",
"(",
"key",
")",
"\n\n",
"_",
",",
"err",
":=",
"pipe",
".",
"Exec",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"count",
",",
"err",
":=",
"value",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"ttl",
",",
"err",
":=",
"expire",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"// If ttl is -1ms, we have to define key expiration.",
"// PTTL return values changed as of Redis 2.8",
"// Now the command returns -2ms if the key does not exist, and -1ms if the key exists, but there is no expiry set",
"// We shouldn't try to set an expiry on a key that doesn't exist",
"if",
"ttl",
"==",
"(",
"-",
"1",
"*",
"time",
".",
"Millisecond",
")",
"{",
"expire",
":=",
"rtx",
".",
"Expire",
"(",
"key",
",",
"expiration",
")",
"\n\n",
"ok",
",",
"err",
":=",
"expire",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"count",
",",
"ttl",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"ok",
"{",
"return",
"count",
",",
"ttl",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"count",
",",
"ttl",
",",
"nil",
"\n\n",
"}"
] | // updateValue will try to increment the counter identified by given key. | [
"updateValue",
"will",
"try",
"to",
"increment",
"the",
"counter",
"identified",
"by",
"given",
"key",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/redis/store.go#L213-L252 |
151,808 | ulule/limiter | drivers/store/redis/store.go | ping | func (store *Store) ping() (bool, error) {
cmd := store.client.Ping()
pong, err := cmd.Result()
if err != nil {
return false, errors.Wrap(err, "limiter: cannot ping redis server")
}
return (pong == "PONG"), nil
} | go | func (store *Store) ping() (bool, error) {
cmd := store.client.Ping()
pong, err := cmd.Result()
if err != nil {
return false, errors.Wrap(err, "limiter: cannot ping redis server")
}
return (pong == "PONG"), nil
} | [
"func",
"(",
"store",
"*",
"Store",
")",
"ping",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"cmd",
":=",
"store",
".",
"client",
".",
"Ping",
"(",
")",
"\n\n",
"pong",
",",
"err",
":=",
"cmd",
".",
"Result",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"(",
"pong",
"==",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // ping checks if redis is alive. | [
"ping",
"checks",
"if",
"redis",
"is",
"alive",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/redis/store.go#L255-L264 |
151,809 | ulule/limiter | drivers/store/memory/store.go | NewStore | func NewStore() limiter.Store {
return NewStoreWithOptions(limiter.StoreOptions{
Prefix: limiter.DefaultPrefix,
CleanUpInterval: limiter.DefaultCleanUpInterval,
})
} | go | func NewStore() limiter.Store {
return NewStoreWithOptions(limiter.StoreOptions{
Prefix: limiter.DefaultPrefix,
CleanUpInterval: limiter.DefaultCleanUpInterval,
})
} | [
"func",
"NewStore",
"(",
")",
"limiter",
".",
"Store",
"{",
"return",
"NewStoreWithOptions",
"(",
"limiter",
".",
"StoreOptions",
"{",
"Prefix",
":",
"limiter",
".",
"DefaultPrefix",
",",
"CleanUpInterval",
":",
"limiter",
".",
"DefaultCleanUpInterval",
",",
"}",
")",
"\n",
"}"
] | // NewStore creates a new instance of memory store with defaults. | [
"NewStore",
"creates",
"a",
"new",
"instance",
"of",
"memory",
"store",
"with",
"defaults",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/memory/store.go#L21-L26 |
151,810 | ulule/limiter | drivers/store/memory/store.go | NewStoreWithOptions | func NewStoreWithOptions(options limiter.StoreOptions) limiter.Store {
return &Store{
Prefix: options.Prefix,
cache: NewCache(options.CleanUpInterval),
}
} | go | func NewStoreWithOptions(options limiter.StoreOptions) limiter.Store {
return &Store{
Prefix: options.Prefix,
cache: NewCache(options.CleanUpInterval),
}
} | [
"func",
"NewStoreWithOptions",
"(",
"options",
"limiter",
".",
"StoreOptions",
")",
"limiter",
".",
"Store",
"{",
"return",
"&",
"Store",
"{",
"Prefix",
":",
"options",
".",
"Prefix",
",",
"cache",
":",
"NewCache",
"(",
"options",
".",
"CleanUpInterval",
")",
",",
"}",
"\n",
"}"
] | // NewStoreWithOptions creates a new instance of memory store with options. | [
"NewStoreWithOptions",
"creates",
"a",
"new",
"instance",
"of",
"memory",
"store",
"with",
"options",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/drivers/store/memory/store.go#L29-L34 |
151,811 | ulule/limiter | network.go | GetIPKey | func (limiter *Limiter) GetIPKey(r *http.Request) string {
return limiter.GetIPWithMask(r).String()
} | go | func (limiter *Limiter) GetIPKey(r *http.Request) string {
return limiter.GetIPWithMask(r).String()
} | [
"func",
"(",
"limiter",
"*",
"Limiter",
")",
"GetIPKey",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"string",
"{",
"return",
"limiter",
".",
"GetIPWithMask",
"(",
"r",
")",
".",
"String",
"(",
")",
"\n",
"}"
] | // GetIPKey extracts IP from request and returns hashed IP to use as store key. | [
"GetIPKey",
"extracts",
"IP",
"from",
"request",
"and",
"returns",
"hashed",
"IP",
"to",
"use",
"as",
"store",
"key",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/network.go#L27-L29 |
151,812 | ulule/limiter | network.go | GetIP | func GetIP(r *http.Request, options ...Options) net.IP {
if len(options) >= 1 && options[0].TrustForwardHeader {
ip := r.Header.Get("X-Forwarded-For")
if ip != "" {
parts := strings.SplitN(ip, ",", 2)
part := strings.TrimSpace(parts[0])
return net.ParseIP(part)
}
ip = strings.TrimSpace(r.Header.Get("X-Real-IP"))
if ip != "" {
return net.ParseIP(ip)
}
}
remoteAddr := strings.TrimSpace(r.RemoteAddr)
host, _, err := net.SplitHostPort(remoteAddr)
if err != nil {
return net.ParseIP(remoteAddr)
}
return net.ParseIP(host)
} | go | func GetIP(r *http.Request, options ...Options) net.IP {
if len(options) >= 1 && options[0].TrustForwardHeader {
ip := r.Header.Get("X-Forwarded-For")
if ip != "" {
parts := strings.SplitN(ip, ",", 2)
part := strings.TrimSpace(parts[0])
return net.ParseIP(part)
}
ip = strings.TrimSpace(r.Header.Get("X-Real-IP"))
if ip != "" {
return net.ParseIP(ip)
}
}
remoteAddr := strings.TrimSpace(r.RemoteAddr)
host, _, err := net.SplitHostPort(remoteAddr)
if err != nil {
return net.ParseIP(remoteAddr)
}
return net.ParseIP(host)
} | [
"func",
"GetIP",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"options",
"...",
"Options",
")",
"net",
".",
"IP",
"{",
"if",
"len",
"(",
"options",
")",
">=",
"1",
"&&",
"options",
"[",
"0",
"]",
".",
"TrustForwardHeader",
"{",
"ip",
":=",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"ip",
"!=",
"\"",
"\"",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"ip",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"part",
":=",
"strings",
".",
"TrimSpace",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"return",
"net",
".",
"ParseIP",
"(",
"part",
")",
"\n",
"}",
"\n\n",
"ip",
"=",
"strings",
".",
"TrimSpace",
"(",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"ip",
"!=",
"\"",
"\"",
"{",
"return",
"net",
".",
"ParseIP",
"(",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"remoteAddr",
":=",
"strings",
".",
"TrimSpace",
"(",
"r",
".",
"RemoteAddr",
")",
"\n",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"remoteAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"net",
".",
"ParseIP",
"(",
"remoteAddr",
")",
"\n",
"}",
"\n\n",
"return",
"net",
".",
"ParseIP",
"(",
"host",
")",
"\n",
"}"
] | // GetIP returns IP address from request.
// If options is defined and TrustForwardHeader is true, it will lookup IP in
// X-Forwarded-For and X-Real-IP headers. | [
"GetIP",
"returns",
"IP",
"address",
"from",
"request",
".",
"If",
"options",
"is",
"defined",
"and",
"TrustForwardHeader",
"is",
"true",
"it",
"will",
"lookup",
"IP",
"in",
"X",
"-",
"Forwarded",
"-",
"For",
"and",
"X",
"-",
"Real",
"-",
"IP",
"headers",
"."
] | d1a9972e76c234debd9f4cf39c847ea174f0faa4 | https://github.com/ulule/limiter/blob/d1a9972e76c234debd9f4cf39c847ea174f0faa4/network.go#L34-L56 |
151,813 | ory/fosite | internal/token_handler.go | NewMockTokenEndpointHandler | func NewMockTokenEndpointHandler(ctrl *gomock.Controller) *MockTokenEndpointHandler {
mock := &MockTokenEndpointHandler{ctrl: ctrl}
mock.recorder = &MockTokenEndpointHandlerMockRecorder{mock}
return mock
} | go | func NewMockTokenEndpointHandler(ctrl *gomock.Controller) *MockTokenEndpointHandler {
mock := &MockTokenEndpointHandler{ctrl: ctrl}
mock.recorder = &MockTokenEndpointHandlerMockRecorder{mock}
return mock
} | [
"func",
"NewMockTokenEndpointHandler",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockTokenEndpointHandler",
"{",
"mock",
":=",
"&",
"MockTokenEndpointHandler",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockTokenEndpointHandlerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockTokenEndpointHandler creates a new mock instance | [
"NewMockTokenEndpointHandler",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/token_handler.go#L28-L32 |
151,814 | ory/fosite | internal/token_handler.go | HandleTokenEndpointRequest | func (m *MockTokenEndpointHandler) HandleTokenEndpointRequest(arg0 context.Context, arg1 fosite.AccessRequester) error {
ret := m.ctrl.Call(m, "HandleTokenEndpointRequest", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockTokenEndpointHandler) HandleTokenEndpointRequest(arg0 context.Context, arg1 fosite.AccessRequester) error {
ret := m.ctrl.Call(m, "HandleTokenEndpointRequest", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockTokenEndpointHandler",
")",
"HandleTokenEndpointRequest",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"fosite",
".",
"AccessRequester",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // HandleTokenEndpointRequest mocks base method | [
"HandleTokenEndpointRequest",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/token_handler.go#L40-L44 |
151,815 | ory/fosite | internal/token_handler.go | PopulateTokenEndpointResponse | func (m *MockTokenEndpointHandler) PopulateTokenEndpointResponse(arg0 context.Context, arg1 fosite.AccessRequester, arg2 fosite.AccessResponder) error {
ret := m.ctrl.Call(m, "PopulateTokenEndpointResponse", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockTokenEndpointHandler) PopulateTokenEndpointResponse(arg0 context.Context, arg1 fosite.AccessRequester, arg2 fosite.AccessResponder) error {
ret := m.ctrl.Call(m, "PopulateTokenEndpointResponse", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockTokenEndpointHandler",
")",
"PopulateTokenEndpointResponse",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"fosite",
".",
"AccessRequester",
",",
"arg2",
"fosite",
".",
"AccessResponder",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // PopulateTokenEndpointResponse mocks base method | [
"PopulateTokenEndpointResponse",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/token_handler.go#L52-L56 |
151,816 | ory/fosite | internal/token_handler.go | PopulateTokenEndpointResponse | func (mr *MockTokenEndpointHandlerMockRecorder) PopulateTokenEndpointResponse(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopulateTokenEndpointResponse", reflect.TypeOf((*MockTokenEndpointHandler)(nil).PopulateTokenEndpointResponse), arg0, arg1, arg2)
} | go | func (mr *MockTokenEndpointHandlerMockRecorder) PopulateTokenEndpointResponse(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopulateTokenEndpointResponse", reflect.TypeOf((*MockTokenEndpointHandler)(nil).PopulateTokenEndpointResponse), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockTokenEndpointHandlerMockRecorder",
")",
"PopulateTokenEndpointResponse",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockTokenEndpointHandler",
")",
"(",
"nil",
")",
".",
"PopulateTokenEndpointResponse",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // PopulateTokenEndpointResponse indicates an expected call of PopulateTokenEndpointResponse | [
"PopulateTokenEndpointResponse",
"indicates",
"an",
"expected",
"call",
"of",
"PopulateTokenEndpointResponse"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/token_handler.go#L59-L61 |
151,817 | ory/fosite | internal/pkce_storage_strategy.go | NewMockPKCERequestStorage | func NewMockPKCERequestStorage(ctrl *gomock.Controller) *MockPKCERequestStorage {
mock := &MockPKCERequestStorage{ctrl: ctrl}
mock.recorder = &MockPKCERequestStorageMockRecorder{mock}
return mock
} | go | func NewMockPKCERequestStorage(ctrl *gomock.Controller) *MockPKCERequestStorage {
mock := &MockPKCERequestStorage{ctrl: ctrl}
mock.recorder = &MockPKCERequestStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockPKCERequestStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPKCERequestStorage",
"{",
"mock",
":=",
"&",
"MockPKCERequestStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPKCERequestStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockPKCERequestStorage creates a new mock instance | [
"NewMockPKCERequestStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/pkce_storage_strategy.go#L28-L32 |
151,818 | ory/fosite | internal/pkce_storage_strategy.go | DeletePKCERequestSession | func (m *MockPKCERequestStorage) DeletePKCERequestSession(arg0 context.Context, arg1 string) error {
ret := m.ctrl.Call(m, "DeletePKCERequestSession", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockPKCERequestStorage) DeletePKCERequestSession(arg0 context.Context, arg1 string) error {
ret := m.ctrl.Call(m, "DeletePKCERequestSession", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockPKCERequestStorage",
")",
"DeletePKCERequestSession",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // DeletePKCERequestSession mocks base method | [
"DeletePKCERequestSession",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/pkce_storage_strategy.go#L52-L56 |
151,819 | ory/fosite | internal/pkce_storage_strategy.go | GetPKCERequestSession | func (mr *MockPKCERequestStorageMockRecorder) GetPKCERequestSession(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPKCERequestSession", reflect.TypeOf((*MockPKCERequestStorage)(nil).GetPKCERequestSession), arg0, arg1, arg2)
} | go | func (mr *MockPKCERequestStorageMockRecorder) GetPKCERequestSession(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPKCERequestSession", reflect.TypeOf((*MockPKCERequestStorage)(nil).GetPKCERequestSession), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockPKCERequestStorageMockRecorder",
")",
"GetPKCERequestSession",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockPKCERequestStorage",
")",
"(",
"nil",
")",
".",
"GetPKCERequestSession",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // GetPKCERequestSession indicates an expected call of GetPKCERequestSession | [
"GetPKCERequestSession",
"indicates",
"an",
"expected",
"call",
"of",
"GetPKCERequestSession"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/pkce_storage_strategy.go#L72-L74 |
151,820 | ory/fosite | compose/compose.go | ComposeAllEnabled | func ComposeAllEnabled(config *Config, storage interface{}, secret []byte, key *rsa.PrivateKey) fosite.OAuth2Provider {
return Compose(
config,
storage,
&CommonStrategy{
CoreStrategy: NewOAuth2HMACStrategy(config, secret, nil),
OpenIDConnectTokenStrategy: NewOpenIDConnectStrategy(config, key),
JWTStrategy: &jwt.RS256JWTStrategy{
PrivateKey: key,
},
},
nil,
OAuth2AuthorizeExplicitFactory,
OAuth2AuthorizeImplicitFactory,
OAuth2ClientCredentialsGrantFactory,
OAuth2RefreshTokenGrantFactory,
OAuth2ResourceOwnerPasswordCredentialsFactory,
OpenIDConnectExplicitFactory,
OpenIDConnectImplicitFactory,
OpenIDConnectHybridFactory,
OpenIDConnectRefreshFactory,
OAuth2TokenIntrospectionFactory,
OAuth2PKCEFactory,
)
} | go | func ComposeAllEnabled(config *Config, storage interface{}, secret []byte, key *rsa.PrivateKey) fosite.OAuth2Provider {
return Compose(
config,
storage,
&CommonStrategy{
CoreStrategy: NewOAuth2HMACStrategy(config, secret, nil),
OpenIDConnectTokenStrategy: NewOpenIDConnectStrategy(config, key),
JWTStrategy: &jwt.RS256JWTStrategy{
PrivateKey: key,
},
},
nil,
OAuth2AuthorizeExplicitFactory,
OAuth2AuthorizeImplicitFactory,
OAuth2ClientCredentialsGrantFactory,
OAuth2RefreshTokenGrantFactory,
OAuth2ResourceOwnerPasswordCredentialsFactory,
OpenIDConnectExplicitFactory,
OpenIDConnectImplicitFactory,
OpenIDConnectHybridFactory,
OpenIDConnectRefreshFactory,
OAuth2TokenIntrospectionFactory,
OAuth2PKCEFactory,
)
} | [
"func",
"ComposeAllEnabled",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"secret",
"[",
"]",
"byte",
",",
"key",
"*",
"rsa",
".",
"PrivateKey",
")",
"fosite",
".",
"OAuth2Provider",
"{",
"return",
"Compose",
"(",
"config",
",",
"storage",
",",
"&",
"CommonStrategy",
"{",
"CoreStrategy",
":",
"NewOAuth2HMACStrategy",
"(",
"config",
",",
"secret",
",",
"nil",
")",
",",
"OpenIDConnectTokenStrategy",
":",
"NewOpenIDConnectStrategy",
"(",
"config",
",",
"key",
")",
",",
"JWTStrategy",
":",
"&",
"jwt",
".",
"RS256JWTStrategy",
"{",
"PrivateKey",
":",
"key",
",",
"}",
",",
"}",
",",
"nil",
",",
"OAuth2AuthorizeExplicitFactory",
",",
"OAuth2AuthorizeImplicitFactory",
",",
"OAuth2ClientCredentialsGrantFactory",
",",
"OAuth2RefreshTokenGrantFactory",
",",
"OAuth2ResourceOwnerPasswordCredentialsFactory",
",",
"OpenIDConnectExplicitFactory",
",",
"OpenIDConnectImplicitFactory",
",",
"OpenIDConnectHybridFactory",
",",
"OpenIDConnectRefreshFactory",
",",
"OAuth2TokenIntrospectionFactory",
",",
"OAuth2PKCEFactory",
",",
")",
"\n",
"}"
] | // ComposeAllEnabled returns a fosite instance with all OAuth2 and OpenID Connect handlers enabled. | [
"ComposeAllEnabled",
"returns",
"a",
"fosite",
"instance",
"with",
"all",
"OAuth2",
"and",
"OpenID",
"Connect",
"handlers",
"enabled",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose.go#L94-L122 |
151,821 | ory/fosite | internal/oauth2_client_storage.go | NewMockClientCredentialsGrantStorage | func NewMockClientCredentialsGrantStorage(ctrl *gomock.Controller) *MockClientCredentialsGrantStorage {
mock := &MockClientCredentialsGrantStorage{ctrl: ctrl}
mock.recorder = &MockClientCredentialsGrantStorageMockRecorder{mock}
return mock
} | go | func NewMockClientCredentialsGrantStorage(ctrl *gomock.Controller) *MockClientCredentialsGrantStorage {
mock := &MockClientCredentialsGrantStorage{ctrl: ctrl}
mock.recorder = &MockClientCredentialsGrantStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockClientCredentialsGrantStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockClientCredentialsGrantStorage",
"{",
"mock",
":=",
"&",
"MockClientCredentialsGrantStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockClientCredentialsGrantStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockClientCredentialsGrantStorage creates a new mock instance | [
"NewMockClientCredentialsGrantStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_client_storage.go#L28-L32 |
151,822 | ory/fosite | internal/oauth2_client_storage.go | GetAccessTokenSession | func (m *MockClientCredentialsGrantStorage) GetAccessTokenSession(arg0 context.Context, arg1 string, arg2 fosite.Session) (fosite.Requester, error) {
ret := m.ctrl.Call(m, "GetAccessTokenSession", arg0, arg1, arg2)
ret0, _ := ret[0].(fosite.Requester)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockClientCredentialsGrantStorage) GetAccessTokenSession(arg0 context.Context, arg1 string, arg2 fosite.Session) (fosite.Requester, error) {
ret := m.ctrl.Call(m, "GetAccessTokenSession", arg0, arg1, arg2)
ret0, _ := ret[0].(fosite.Requester)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockClientCredentialsGrantStorage",
")",
"GetAccessTokenSession",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"string",
",",
"arg2",
"fosite",
".",
"Session",
")",
"(",
"fosite",
".",
"Requester",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"fosite",
".",
"Requester",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetAccessTokenSession mocks base method | [
"GetAccessTokenSession",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_client_storage.go#L64-L69 |
151,823 | ory/fosite | compose/compose_pkce.go | OAuth2PKCEFactory | func OAuth2PKCEFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &pkce.Handler{
AuthorizeCodeStrategy: strategy.(oauth2.AuthorizeCodeStrategy),
Storage: storage.(pkce.PKCERequestStorage),
Force: config.EnforcePKCE,
EnablePlainChallengeMethod: config.EnablePKCEPlainChallengeMethod,
}
} | go | func OAuth2PKCEFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &pkce.Handler{
AuthorizeCodeStrategy: strategy.(oauth2.AuthorizeCodeStrategy),
Storage: storage.(pkce.PKCERequestStorage),
Force: config.EnforcePKCE,
EnablePlainChallengeMethod: config.EnablePKCEPlainChallengeMethod,
}
} | [
"func",
"OAuth2PKCEFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"pkce",
".",
"Handler",
"{",
"AuthorizeCodeStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"AuthorizeCodeStrategy",
")",
",",
"Storage",
":",
"storage",
".",
"(",
"pkce",
".",
"PKCERequestStorage",
")",
",",
"Force",
":",
"config",
".",
"EnforcePKCE",
",",
"EnablePlainChallengeMethod",
":",
"config",
".",
"EnablePKCEPlainChallengeMethod",
",",
"}",
"\n",
"}"
] | // OAuth2PKCEFactory creates a PKCE handler. | [
"OAuth2PKCEFactory",
"creates",
"a",
"PKCE",
"handler",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_pkce.go#L30-L37 |
151,824 | ory/fosite | internal/client.go | GetHashedSecret | func (m *MockClient) GetHashedSecret() []byte {
ret := m.ctrl.Call(m, "GetHashedSecret")
ret0, _ := ret[0].([]byte)
return ret0
} | go | func (m *MockClient) GetHashedSecret() []byte {
ret := m.ctrl.Call(m, "GetHashedSecret")
ret0, _ := ret[0].([]byte)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockClient",
")",
"GetHashedSecret",
"(",
")",
"[",
"]",
"byte",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"[",
"]",
"byte",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetHashedSecret mocks base method | [
"GetHashedSecret",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/client.go#L63-L67 |
151,825 | ory/fosite | internal/client.go | IsPublic | func (m *MockClient) IsPublic() bool {
ret := m.ctrl.Call(m, "IsPublic")
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockClient) IsPublic() bool {
ret := m.ctrl.Call(m, "IsPublic")
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockClient",
")",
"IsPublic",
"(",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // IsPublic mocks base method | [
"IsPublic",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/client.go#L123-L127 |
151,826 | ory/fosite | token/jwt/jwt.go | Generate | func (j *RS256JWTStrategy) Generate(ctx context.Context, claims jwt.Claims, header Mapper) (string, string, error) {
if header == nil || claims == nil {
return "", "", errors.New("Either claims or header is nil.")
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header = assign(token.Header, header.ToMap())
var sig, sstr string
var err error
if sstr, err = token.SigningString(); err != nil {
return "", "", errors.WithStack(err)
}
if sig, err = token.Method.Sign(sstr, j.PrivateKey); err != nil {
return "", "", errors.WithStack(err)
}
return fmt.Sprintf("%s.%s", sstr, sig), sig, nil
} | go | func (j *RS256JWTStrategy) Generate(ctx context.Context, claims jwt.Claims, header Mapper) (string, string, error) {
if header == nil || claims == nil {
return "", "", errors.New("Either claims or header is nil.")
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header = assign(token.Header, header.ToMap())
var sig, sstr string
var err error
if sstr, err = token.SigningString(); err != nil {
return "", "", errors.WithStack(err)
}
if sig, err = token.Method.Sign(sstr, j.PrivateKey); err != nil {
return "", "", errors.WithStack(err)
}
return fmt.Sprintf("%s.%s", sstr, sig), sig, nil
} | [
"func",
"(",
"j",
"*",
"RS256JWTStrategy",
")",
"Generate",
"(",
"ctx",
"context",
".",
"Context",
",",
"claims",
"jwt",
".",
"Claims",
",",
"header",
"Mapper",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"if",
"header",
"==",
"nil",
"||",
"claims",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"token",
":=",
"jwt",
".",
"NewWithClaims",
"(",
"jwt",
".",
"SigningMethodRS256",
",",
"claims",
")",
"\n",
"token",
".",
"Header",
"=",
"assign",
"(",
"token",
".",
"Header",
",",
"header",
".",
"ToMap",
"(",
")",
")",
"\n\n",
"var",
"sig",
",",
"sstr",
"string",
"\n",
"var",
"err",
"error",
"\n",
"if",
"sstr",
",",
"err",
"=",
"token",
".",
"SigningString",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"errors",
".",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"sig",
",",
"err",
"=",
"token",
".",
"Method",
".",
"Sign",
"(",
"sstr",
",",
"j",
".",
"PrivateKey",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"errors",
".",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"sstr",
",",
"sig",
")",
",",
"sig",
",",
"nil",
"\n",
"}"
] | // Generate generates a new authorize code or returns an error. set secret | [
"Generate",
"generates",
"a",
"new",
"authorize",
"code",
"or",
"returns",
"an",
"error",
".",
"set",
"secret"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/jwt.go#L55-L74 |
151,827 | ory/fosite | token/jwt/jwt.go | Decode | func (j *RS256JWTStrategy) Decode(ctx context.Context, token string) (*jwt.Token, error) {
// Parse the token.
parsedToken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.Errorf("Unexpected signing method: %v", t.Header["alg"])
}
return &j.PrivateKey.PublicKey, nil
})
if err != nil {
return parsedToken, errors.WithStack(err)
} else if !parsedToken.Valid {
return parsedToken, errors.WithStack(fosite.ErrInactiveToken)
}
return parsedToken, err
} | go | func (j *RS256JWTStrategy) Decode(ctx context.Context, token string) (*jwt.Token, error) {
// Parse the token.
parsedToken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.Errorf("Unexpected signing method: %v", t.Header["alg"])
}
return &j.PrivateKey.PublicKey, nil
})
if err != nil {
return parsedToken, errors.WithStack(err)
} else if !parsedToken.Valid {
return parsedToken, errors.WithStack(fosite.ErrInactiveToken)
}
return parsedToken, err
} | [
"func",
"(",
"j",
"*",
"RS256JWTStrategy",
")",
"Decode",
"(",
"ctx",
"context",
".",
"Context",
",",
"token",
"string",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"// Parse the token.",
"parsedToken",
",",
"err",
":=",
"jwt",
".",
"Parse",
"(",
"token",
",",
"func",
"(",
"t",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"t",
".",
"Method",
".",
"(",
"*",
"jwt",
".",
"SigningMethodRSA",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
".",
"Header",
"[",
"\"",
"\"",
"]",
")",
"\n",
"}",
"\n",
"return",
"&",
"j",
".",
"PrivateKey",
".",
"PublicKey",
",",
"nil",
"\n",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"parsedToken",
",",
"errors",
".",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"else",
"if",
"!",
"parsedToken",
".",
"Valid",
"{",
"return",
"parsedToken",
",",
"errors",
".",
"WithStack",
"(",
"fosite",
".",
"ErrInactiveToken",
")",
"\n",
"}",
"\n\n",
"return",
"parsedToken",
",",
"err",
"\n",
"}"
] | // Decode will decode a JWT token | [
"Decode",
"will",
"decode",
"a",
"JWT",
"token"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/jwt.go#L86-L102 |
151,828 | ory/fosite | token/jwt/jwt.go | GetSignature | func (j *RS256JWTStrategy) GetSignature(ctx context.Context, token string) (string, error) {
split := strings.Split(token, ".")
if len(split) != 3 {
return "", errors.New("Header, body and signature must all be set")
}
return split[2], nil
} | go | func (j *RS256JWTStrategy) GetSignature(ctx context.Context, token string) (string, error) {
split := strings.Split(token, ".")
if len(split) != 3 {
return "", errors.New("Header, body and signature must all be set")
}
return split[2], nil
} | [
"func",
"(",
"j",
"*",
"RS256JWTStrategy",
")",
"GetSignature",
"(",
"ctx",
"context",
".",
"Context",
",",
"token",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"split",
":=",
"strings",
".",
"Split",
"(",
"token",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"split",
")",
"!=",
"3",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"split",
"[",
"2",
"]",
",",
"nil",
"\n",
"}"
] | // GetSignature will return the signature of a token | [
"GetSignature",
"will",
"return",
"the",
"signature",
"of",
"a",
"token"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/jwt.go#L105-L111 |
151,829 | ory/fosite | token/jwt/jwt.go | Hash | func (j *RS256JWTStrategy) Hash(ctx context.Context, in []byte) ([]byte, error) {
// SigningMethodRS256
hash := sha256.New()
_, err := hash.Write(in)
if err != nil {
return []byte{}, errors.WithStack(err)
}
return hash.Sum([]byte{}), nil
} | go | func (j *RS256JWTStrategy) Hash(ctx context.Context, in []byte) ([]byte, error) {
// SigningMethodRS256
hash := sha256.New()
_, err := hash.Write(in)
if err != nil {
return []byte{}, errors.WithStack(err)
}
return hash.Sum([]byte{}), nil
} | [
"func",
"(",
"j",
"*",
"RS256JWTStrategy",
")",
"Hash",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// SigningMethodRS256",
"hash",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"hash",
".",
"Write",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
",",
"errors",
".",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"hash",
".",
"Sum",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
",",
"nil",
"\n",
"}"
] | // Hash will return a given hash based on the byte input or an error upon fail | [
"Hash",
"will",
"return",
"a",
"given",
"hash",
"based",
"on",
"the",
"byte",
"input",
"or",
"an",
"error",
"upon",
"fail"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/jwt.go#L114-L122 |
151,830 | ory/fosite | storage/transactional.go | MaybeBeginTx | func MaybeBeginTx(ctx context.Context, storage interface{}) (context.Context, error) {
// the type assertion checks whether the dynamic type of `storage` implements `Transactional`
txnStorage, transactional := storage.(Transactional)
if transactional {
return txnStorage.BeginTX(ctx)
} else {
return ctx, nil
}
} | go | func MaybeBeginTx(ctx context.Context, storage interface{}) (context.Context, error) {
// the type assertion checks whether the dynamic type of `storage` implements `Transactional`
txnStorage, transactional := storage.(Transactional)
if transactional {
return txnStorage.BeginTX(ctx)
} else {
return ctx, nil
}
} | [
"func",
"MaybeBeginTx",
"(",
"ctx",
"context",
".",
"Context",
",",
"storage",
"interface",
"{",
"}",
")",
"(",
"context",
".",
"Context",
",",
"error",
")",
"{",
"// the type assertion checks whether the dynamic type of `storage` implements `Transactional`",
"txnStorage",
",",
"transactional",
":=",
"storage",
".",
"(",
"Transactional",
")",
"\n",
"if",
"transactional",
"{",
"return",
"txnStorage",
".",
"BeginTX",
"(",
"ctx",
")",
"\n",
"}",
"else",
"{",
"return",
"ctx",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // MaybeBeginTx is a helper function that can be used to initiate a transaction if the supplied storage
// implements the `Transactional` interface. | [
"MaybeBeginTx",
"is",
"a",
"helper",
"function",
"that",
"can",
"be",
"used",
"to",
"initiate",
"a",
"transaction",
"if",
"the",
"supplied",
"storage",
"implements",
"the",
"Transactional",
"interface",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/storage/transactional.go#L25-L33 |
151,831 | ory/fosite | storage/transactional.go | MaybeCommitTx | func MaybeCommitTx(ctx context.Context, storage interface{}) error {
txnStorage, transactional := storage.(Transactional)
if transactional {
return txnStorage.Commit(ctx)
} else {
return nil
}
} | go | func MaybeCommitTx(ctx context.Context, storage interface{}) error {
txnStorage, transactional := storage.(Transactional)
if transactional {
return txnStorage.Commit(ctx)
} else {
return nil
}
} | [
"func",
"MaybeCommitTx",
"(",
"ctx",
"context",
".",
"Context",
",",
"storage",
"interface",
"{",
"}",
")",
"error",
"{",
"txnStorage",
",",
"transactional",
":=",
"storage",
".",
"(",
"Transactional",
")",
"\n",
"if",
"transactional",
"{",
"return",
"txnStorage",
".",
"Commit",
"(",
"ctx",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MaybeCommitTx is a helper function that can be used to commit a transaction if the supplied storage
// implements the `Transactional` interface. | [
"MaybeCommitTx",
"is",
"a",
"helper",
"function",
"that",
"can",
"be",
"used",
"to",
"commit",
"a",
"transaction",
"if",
"the",
"supplied",
"storage",
"implements",
"the",
"Transactional",
"interface",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/storage/transactional.go#L37-L44 |
151,832 | ory/fosite | storage/transactional.go | MaybeRollbackTx | func MaybeRollbackTx(ctx context.Context, storage interface{}) error {
txnStorage, transactional := storage.(Transactional)
if transactional {
return txnStorage.Rollback(ctx)
} else {
return nil
}
} | go | func MaybeRollbackTx(ctx context.Context, storage interface{}) error {
txnStorage, transactional := storage.(Transactional)
if transactional {
return txnStorage.Rollback(ctx)
} else {
return nil
}
} | [
"func",
"MaybeRollbackTx",
"(",
"ctx",
"context",
".",
"Context",
",",
"storage",
"interface",
"{",
"}",
")",
"error",
"{",
"txnStorage",
",",
"transactional",
":=",
"storage",
".",
"(",
"Transactional",
")",
"\n",
"if",
"transactional",
"{",
"return",
"txnStorage",
".",
"Rollback",
"(",
"ctx",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MaybeRollbackTx is a helper function that can be used to rollback a transaction if the supplied storage
// implements the `Transactional` interface. | [
"MaybeRollbackTx",
"is",
"a",
"helper",
"function",
"that",
"can",
"be",
"used",
"to",
"rollback",
"a",
"transaction",
"if",
"the",
"supplied",
"storage",
"implements",
"the",
"Transactional",
"interface",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/storage/transactional.go#L48-L55 |
151,833 | ory/fosite | internal/authorize_request.go | NewMockAuthorizeRequester | func NewMockAuthorizeRequester(ctrl *gomock.Controller) *MockAuthorizeRequester {
mock := &MockAuthorizeRequester{ctrl: ctrl}
mock.recorder = &MockAuthorizeRequesterMockRecorder{mock}
return mock
} | go | func NewMockAuthorizeRequester(ctrl *gomock.Controller) *MockAuthorizeRequester {
mock := &MockAuthorizeRequester{ctrl: ctrl}
mock.recorder = &MockAuthorizeRequesterMockRecorder{mock}
return mock
} | [
"func",
"NewMockAuthorizeRequester",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAuthorizeRequester",
"{",
"mock",
":=",
"&",
"MockAuthorizeRequester",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAuthorizeRequesterMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAuthorizeRequester creates a new mock instance | [
"NewMockAuthorizeRequester",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_request.go#L29-L33 |
151,834 | ory/fosite | internal/authorize_request.go | GetRedirectURI | func (m *MockAuthorizeRequester) GetRedirectURI() *url.URL {
ret := m.ctrl.Call(m, "GetRedirectURI")
ret0, _ := ret[0].(*url.URL)
return ret0
} | go | func (m *MockAuthorizeRequester) GetRedirectURI() *url.URL {
ret := m.ctrl.Call(m, "GetRedirectURI")
ret0, _ := ret[0].(*url.URL)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeRequester",
")",
"GetRedirectURI",
"(",
")",
"*",
"url",
".",
"URL",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"url",
".",
"URL",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetRedirectURI mocks base method | [
"GetRedirectURI",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_request.go#L111-L115 |
151,835 | ory/fosite | internal/authorize_request.go | GetRequestForm | func (m *MockAuthorizeRequester) GetRequestForm() url.Values {
ret := m.ctrl.Call(m, "GetRequestForm")
ret0, _ := ret[0].(url.Values)
return ret0
} | go | func (m *MockAuthorizeRequester) GetRequestForm() url.Values {
ret := m.ctrl.Call(m, "GetRequestForm")
ret0, _ := ret[0].(url.Values)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeRequester",
")",
"GetRequestForm",
"(",
")",
"url",
".",
"Values",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"url",
".",
"Values",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetRequestForm mocks base method | [
"GetRequestForm",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_request.go#L123-L127 |
151,836 | ory/fosite | internal/authorize_request.go | IsRedirectURIValid | func (m *MockAuthorizeRequester) IsRedirectURIValid() bool {
ret := m.ctrl.Call(m, "IsRedirectURIValid")
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockAuthorizeRequester) IsRedirectURIValid() bool {
ret := m.ctrl.Call(m, "IsRedirectURIValid")
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeRequester",
")",
"IsRedirectURIValid",
"(",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // IsRedirectURIValid mocks base method | [
"IsRedirectURIValid",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_request.go#L227-L231 |
151,837 | ory/fosite | internal/authorize_request.go | SetResponseTypeHandled | func (m *MockAuthorizeRequester) SetResponseTypeHandled(arg0 string) {
m.ctrl.Call(m, "SetResponseTypeHandled", arg0)
} | go | func (m *MockAuthorizeRequester) SetResponseTypeHandled(arg0 string) {
m.ctrl.Call(m, "SetResponseTypeHandled", arg0)
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeRequester",
")",
"SetResponseTypeHandled",
"(",
"arg0",
"string",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] | // SetResponseTypeHandled mocks base method | [
"SetResponseTypeHandled",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_request.go#L291-L293 |
151,838 | ory/fosite | token/jwt/claims_jwt.go | FromMap | func (c *JWTClaims) FromMap(m map[string]interface{}) {
c.Extra = make(map[string]interface{})
for k, v := range m {
switch k {
case "jti":
if s, ok := v.(string); ok {
c.JTI = s
}
case "sub":
if s, ok := v.(string); ok {
c.Subject = s
}
case "iss":
if s, ok := v.(string); ok {
c.Issuer = s
}
case "aud":
if s, ok := v.(string); ok {
c.Audience = []string{s}
} else if s, ok := v.([]string); ok {
c.Audience = s
}
case "iat":
switch v.(type) {
case float64:
c.IssuedAt = time.Unix(int64(v.(float64)), 0).UTC()
case int64:
c.IssuedAt = time.Unix(v.(int64), 0).UTC()
}
case "nbf":
switch v.(type) {
case float64:
c.NotBefore = time.Unix(int64(v.(float64)), 0).UTC()
case int64:
c.NotBefore = time.Unix(v.(int64), 0).UTC()
}
case "exp":
switch v.(type) {
case float64:
c.ExpiresAt = time.Unix(int64(v.(float64)), 0).UTC()
case int64:
c.ExpiresAt = time.Unix(v.(int64), 0).UTC()
}
case "scp":
switch v.(type) {
case []string:
c.Scope = v.([]string)
case []interface{}:
c.Scope = make([]string, len(v.([]interface{})))
for i, vi := range v.([]interface{}) {
if s, ok := vi.(string); ok {
c.Scope[i] = s
}
}
}
default:
c.Extra[k] = v
}
}
} | go | func (c *JWTClaims) FromMap(m map[string]interface{}) {
c.Extra = make(map[string]interface{})
for k, v := range m {
switch k {
case "jti":
if s, ok := v.(string); ok {
c.JTI = s
}
case "sub":
if s, ok := v.(string); ok {
c.Subject = s
}
case "iss":
if s, ok := v.(string); ok {
c.Issuer = s
}
case "aud":
if s, ok := v.(string); ok {
c.Audience = []string{s}
} else if s, ok := v.([]string); ok {
c.Audience = s
}
case "iat":
switch v.(type) {
case float64:
c.IssuedAt = time.Unix(int64(v.(float64)), 0).UTC()
case int64:
c.IssuedAt = time.Unix(v.(int64), 0).UTC()
}
case "nbf":
switch v.(type) {
case float64:
c.NotBefore = time.Unix(int64(v.(float64)), 0).UTC()
case int64:
c.NotBefore = time.Unix(v.(int64), 0).UTC()
}
case "exp":
switch v.(type) {
case float64:
c.ExpiresAt = time.Unix(int64(v.(float64)), 0).UTC()
case int64:
c.ExpiresAt = time.Unix(v.(int64), 0).UTC()
}
case "scp":
switch v.(type) {
case []string:
c.Scope = v.([]string)
case []interface{}:
c.Scope = make([]string, len(v.([]interface{})))
for i, vi := range v.([]interface{}) {
if s, ok := vi.(string); ok {
c.Scope[i] = s
}
}
}
default:
c.Extra[k] = v
}
}
} | [
"func",
"(",
"c",
"*",
"JWTClaims",
")",
"FromMap",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"c",
".",
"Extra",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"m",
"{",
"switch",
"k",
"{",
"case",
"\"",
"\"",
":",
"if",
"s",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"{",
"c",
".",
"JTI",
"=",
"s",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"s",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"{",
"c",
".",
"Subject",
"=",
"s",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"s",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"{",
"c",
".",
"Issuer",
"=",
"s",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"s",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"{",
"c",
".",
"Audience",
"=",
"[",
"]",
"string",
"{",
"s",
"}",
"\n",
"}",
"else",
"if",
"s",
",",
"ok",
":=",
"v",
".",
"(",
"[",
"]",
"string",
")",
";",
"ok",
"{",
"c",
".",
"Audience",
"=",
"s",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"switch",
"v",
".",
"(",
"type",
")",
"{",
"case",
"float64",
":",
"c",
".",
"IssuedAt",
"=",
"time",
".",
"Unix",
"(",
"int64",
"(",
"v",
".",
"(",
"float64",
")",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"case",
"int64",
":",
"c",
".",
"IssuedAt",
"=",
"time",
".",
"Unix",
"(",
"v",
".",
"(",
"int64",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"switch",
"v",
".",
"(",
"type",
")",
"{",
"case",
"float64",
":",
"c",
".",
"NotBefore",
"=",
"time",
".",
"Unix",
"(",
"int64",
"(",
"v",
".",
"(",
"float64",
")",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"case",
"int64",
":",
"c",
".",
"NotBefore",
"=",
"time",
".",
"Unix",
"(",
"v",
".",
"(",
"int64",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"switch",
"v",
".",
"(",
"type",
")",
"{",
"case",
"float64",
":",
"c",
".",
"ExpiresAt",
"=",
"time",
".",
"Unix",
"(",
"int64",
"(",
"v",
".",
"(",
"float64",
")",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"case",
"int64",
":",
"c",
".",
"ExpiresAt",
"=",
"time",
".",
"Unix",
"(",
"v",
".",
"(",
"int64",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"switch",
"v",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"string",
":",
"c",
".",
"Scope",
"=",
"v",
".",
"(",
"[",
"]",
"string",
")",
"\n",
"case",
"[",
"]",
"interface",
"{",
"}",
":",
"c",
".",
"Scope",
"=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"v",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
")",
")",
"\n",
"for",
"i",
",",
"vi",
":=",
"range",
"v",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"if",
"s",
",",
"ok",
":=",
"vi",
".",
"(",
"string",
")",
";",
"ok",
"{",
"c",
".",
"Scope",
"[",
"i",
"]",
"=",
"s",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"c",
".",
"Extra",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // FromMap will set the claims based on a mapping | [
"FromMap",
"will",
"set",
"the",
"claims",
"based",
"on",
"a",
"mapping"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/claims_jwt.go#L112-L171 |
151,839 | ory/fosite | internal/access_token_strategy.go | NewMockAccessTokenStrategy | func NewMockAccessTokenStrategy(ctrl *gomock.Controller) *MockAccessTokenStrategy {
mock := &MockAccessTokenStrategy{ctrl: ctrl}
mock.recorder = &MockAccessTokenStrategyMockRecorder{mock}
return mock
} | go | func NewMockAccessTokenStrategy(ctrl *gomock.Controller) *MockAccessTokenStrategy {
mock := &MockAccessTokenStrategy{ctrl: ctrl}
mock.recorder = &MockAccessTokenStrategyMockRecorder{mock}
return mock
} | [
"func",
"NewMockAccessTokenStrategy",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAccessTokenStrategy",
"{",
"mock",
":=",
"&",
"MockAccessTokenStrategy",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAccessTokenStrategyMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAccessTokenStrategy creates a new mock instance | [
"NewMockAccessTokenStrategy",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/access_token_strategy.go#L28-L32 |
151,840 | ory/fosite | internal/authorize_code_storage.go | NewMockAuthorizeCodeStorage | func NewMockAuthorizeCodeStorage(ctrl *gomock.Controller) *MockAuthorizeCodeStorage {
mock := &MockAuthorizeCodeStorage{ctrl: ctrl}
mock.recorder = &MockAuthorizeCodeStorageMockRecorder{mock}
return mock
} | go | func NewMockAuthorizeCodeStorage(ctrl *gomock.Controller) *MockAuthorizeCodeStorage {
mock := &MockAuthorizeCodeStorage{ctrl: ctrl}
mock.recorder = &MockAuthorizeCodeStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockAuthorizeCodeStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAuthorizeCodeStorage",
"{",
"mock",
":=",
"&",
"MockAuthorizeCodeStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAuthorizeCodeStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAuthorizeCodeStorage creates a new mock instance | [
"NewMockAuthorizeCodeStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_storage.go#L28-L32 |
151,841 | ory/fosite | internal/authorize_code_storage.go | CreateAuthorizeCodeSession | func (mr *MockAuthorizeCodeStorageMockRecorder) CreateAuthorizeCodeSession(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAuthorizeCodeSession", reflect.TypeOf((*MockAuthorizeCodeStorage)(nil).CreateAuthorizeCodeSession), arg0, arg1, arg2)
} | go | func (mr *MockAuthorizeCodeStorageMockRecorder) CreateAuthorizeCodeSession(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAuthorizeCodeSession", reflect.TypeOf((*MockAuthorizeCodeStorage)(nil).CreateAuthorizeCodeSession), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockAuthorizeCodeStorageMockRecorder",
")",
"CreateAuthorizeCodeSession",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAuthorizeCodeStorage",
")",
"(",
"nil",
")",
".",
"CreateAuthorizeCodeSession",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // CreateAuthorizeCodeSession indicates an expected call of CreateAuthorizeCodeSession | [
"CreateAuthorizeCodeSession",
"indicates",
"an",
"expected",
"call",
"of",
"CreateAuthorizeCodeSession"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_storage.go#L47-L49 |
151,842 | ory/fosite | internal/authorize_code_strategy.go | NewMockAuthorizeCodeStrategy | func NewMockAuthorizeCodeStrategy(ctrl *gomock.Controller) *MockAuthorizeCodeStrategy {
mock := &MockAuthorizeCodeStrategy{ctrl: ctrl}
mock.recorder = &MockAuthorizeCodeStrategyMockRecorder{mock}
return mock
} | go | func NewMockAuthorizeCodeStrategy(ctrl *gomock.Controller) *MockAuthorizeCodeStrategy {
mock := &MockAuthorizeCodeStrategy{ctrl: ctrl}
mock.recorder = &MockAuthorizeCodeStrategyMockRecorder{mock}
return mock
} | [
"func",
"NewMockAuthorizeCodeStrategy",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAuthorizeCodeStrategy",
"{",
"mock",
":=",
"&",
"MockAuthorizeCodeStrategy",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAuthorizeCodeStrategyMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAuthorizeCodeStrategy creates a new mock instance | [
"NewMockAuthorizeCodeStrategy",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_strategy.go#L28-L32 |
151,843 | ory/fosite | internal/authorize_code_strategy.go | AuthorizeCodeSignature | func (m *MockAuthorizeCodeStrategy) AuthorizeCodeSignature(arg0 string) string {
ret := m.ctrl.Call(m, "AuthorizeCodeSignature", arg0)
ret0, _ := ret[0].(string)
return ret0
} | go | func (m *MockAuthorizeCodeStrategy) AuthorizeCodeSignature(arg0 string) string {
ret := m.ctrl.Call(m, "AuthorizeCodeSignature", arg0)
ret0, _ := ret[0].(string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeCodeStrategy",
")",
"AuthorizeCodeSignature",
"(",
"arg0",
"string",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // AuthorizeCodeSignature mocks base method | [
"AuthorizeCodeSignature",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_strategy.go#L40-L44 |
151,844 | ory/fosite | internal/authorize_code_strategy.go | AuthorizeCodeSignature | func (mr *MockAuthorizeCodeStrategyMockRecorder) AuthorizeCodeSignature(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCodeSignature", reflect.TypeOf((*MockAuthorizeCodeStrategy)(nil).AuthorizeCodeSignature), arg0)
} | go | func (mr *MockAuthorizeCodeStrategyMockRecorder) AuthorizeCodeSignature(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCodeSignature", reflect.TypeOf((*MockAuthorizeCodeStrategy)(nil).AuthorizeCodeSignature), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockAuthorizeCodeStrategyMockRecorder",
")",
"AuthorizeCodeSignature",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAuthorizeCodeStrategy",
")",
"(",
"nil",
")",
".",
"AuthorizeCodeSignature",
")",
",",
"arg0",
")",
"\n",
"}"
] | // AuthorizeCodeSignature indicates an expected call of AuthorizeCodeSignature | [
"AuthorizeCodeSignature",
"indicates",
"an",
"expected",
"call",
"of",
"AuthorizeCodeSignature"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_strategy.go#L47-L49 |
151,845 | ory/fosite | internal/authorize_code_strategy.go | GenerateAuthorizeCode | func (m *MockAuthorizeCodeStrategy) GenerateAuthorizeCode(arg0 context.Context, arg1 fosite.Requester) (string, string, error) {
ret := m.ctrl.Call(m, "GenerateAuthorizeCode", arg0, arg1)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(string)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | func (m *MockAuthorizeCodeStrategy) GenerateAuthorizeCode(arg0 context.Context, arg1 fosite.Requester) (string, string, error) {
ret := m.ctrl.Call(m, "GenerateAuthorizeCode", arg0, arg1)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(string)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeCodeStrategy",
")",
"GenerateAuthorizeCode",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"fosite",
".",
"Requester",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"string",
")",
"\n",
"ret2",
",",
"_",
":=",
"ret",
"[",
"2",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
",",
"ret2",
"\n",
"}"
] | // GenerateAuthorizeCode mocks base method | [
"GenerateAuthorizeCode",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_strategy.go#L52-L58 |
151,846 | ory/fosite | internal/authorize_code_strategy.go | ValidateAuthorizeCode | func (m *MockAuthorizeCodeStrategy) ValidateAuthorizeCode(arg0 context.Context, arg1 fosite.Requester, arg2 string) error {
ret := m.ctrl.Call(m, "ValidateAuthorizeCode", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockAuthorizeCodeStrategy) ValidateAuthorizeCode(arg0 context.Context, arg1 fosite.Requester, arg2 string) error {
ret := m.ctrl.Call(m, "ValidateAuthorizeCode", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeCodeStrategy",
")",
"ValidateAuthorizeCode",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"fosite",
".",
"Requester",
",",
"arg2",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ValidateAuthorizeCode mocks base method | [
"ValidateAuthorizeCode",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_code_strategy.go#L66-L70 |
151,847 | ory/fosite | internal/hash.go | NewMockHasher | func NewMockHasher(ctrl *gomock.Controller) *MockHasher {
mock := &MockHasher{ctrl: ctrl}
mock.recorder = &MockHasherMockRecorder{mock}
return mock
} | go | func NewMockHasher(ctrl *gomock.Controller) *MockHasher {
mock := &MockHasher{ctrl: ctrl}
mock.recorder = &MockHasherMockRecorder{mock}
return mock
} | [
"func",
"NewMockHasher",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockHasher",
"{",
"mock",
":=",
"&",
"MockHasher",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockHasherMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockHasher creates a new mock instance | [
"NewMockHasher",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/hash.go#L26-L30 |
151,848 | ory/fosite | internal/hash.go | Compare | func (m *MockHasher) Compare(arg0 context.Context, arg1, arg2 []byte) error {
ret := m.ctrl.Call(m, "Compare", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockHasher) Compare(arg0 context.Context, arg1, arg2 []byte) error {
ret := m.ctrl.Call(m, "Compare", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockHasher",
")",
"Compare",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
",",
"arg2",
"[",
"]",
"byte",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Compare mocks base method | [
"Compare",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/hash.go#L38-L42 |
151,849 | ory/fosite | internal/hash.go | Compare | func (mr *MockHasherMockRecorder) Compare(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compare", reflect.TypeOf((*MockHasher)(nil).Compare), arg0, arg1, arg2)
} | go | func (mr *MockHasherMockRecorder) Compare(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compare", reflect.TypeOf((*MockHasher)(nil).Compare), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockHasherMockRecorder",
")",
"Compare",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockHasher",
")",
"(",
"nil",
")",
".",
"Compare",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // Compare indicates an expected call of Compare | [
"Compare",
"indicates",
"an",
"expected",
"call",
"of",
"Compare"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/hash.go#L45-L47 |
151,850 | ory/fosite | internal/hash.go | Hash | func (m *MockHasher) Hash(arg0 context.Context, arg1 []byte) ([]byte, error) {
ret := m.ctrl.Call(m, "Hash", arg0, arg1)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockHasher) Hash(arg0 context.Context, arg1 []byte) ([]byte, error) {
ret := m.ctrl.Call(m, "Hash", arg0, arg1)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockHasher",
")",
"Hash",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"[",
"]",
"byte",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // Hash mocks base method | [
"Hash",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/hash.go#L50-L55 |
151,851 | ory/fosite | internal/oauth2_revoke_storage.go | NewMockTokenRevocationStorage | func NewMockTokenRevocationStorage(ctrl *gomock.Controller) *MockTokenRevocationStorage {
mock := &MockTokenRevocationStorage{ctrl: ctrl}
mock.recorder = &MockTokenRevocationStorageMockRecorder{mock}
return mock
} | go | func NewMockTokenRevocationStorage(ctrl *gomock.Controller) *MockTokenRevocationStorage {
mock := &MockTokenRevocationStorage{ctrl: ctrl}
mock.recorder = &MockTokenRevocationStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockTokenRevocationStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockTokenRevocationStorage",
"{",
"mock",
":=",
"&",
"MockTokenRevocationStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockTokenRevocationStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockTokenRevocationStorage creates a new mock instance | [
"NewMockTokenRevocationStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_revoke_storage.go#L28-L32 |
151,852 | ory/fosite | internal/oauth2_revoke_storage.go | RevokeRefreshToken | func (mr *MockTokenRevocationStorageMockRecorder) RevokeRefreshToken(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeRefreshToken", reflect.TypeOf((*MockTokenRevocationStorage)(nil).RevokeRefreshToken), arg0, arg1)
} | go | func (mr *MockTokenRevocationStorageMockRecorder) RevokeRefreshToken(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeRefreshToken", reflect.TypeOf((*MockTokenRevocationStorage)(nil).RevokeRefreshToken), arg0, arg1)
} | [
"func",
"(",
"mr",
"*",
"MockTokenRevocationStorageMockRecorder",
")",
"RevokeRefreshToken",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockTokenRevocationStorage",
")",
"(",
"nil",
")",
".",
"RevokeRefreshToken",
")",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // RevokeRefreshToken indicates an expected call of RevokeRefreshToken | [
"RevokeRefreshToken",
"indicates",
"an",
"expected",
"call",
"of",
"RevokeRefreshToken"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_revoke_storage.go#L133-L135 |
151,853 | ory/fosite | internal/access_token_storage.go | NewMockAccessTokenStorage | func NewMockAccessTokenStorage(ctrl *gomock.Controller) *MockAccessTokenStorage {
mock := &MockAccessTokenStorage{ctrl: ctrl}
mock.recorder = &MockAccessTokenStorageMockRecorder{mock}
return mock
} | go | func NewMockAccessTokenStorage(ctrl *gomock.Controller) *MockAccessTokenStorage {
mock := &MockAccessTokenStorage{ctrl: ctrl}
mock.recorder = &MockAccessTokenStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockAccessTokenStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAccessTokenStorage",
"{",
"mock",
":=",
"&",
"MockAccessTokenStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAccessTokenStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAccessTokenStorage creates a new mock instance | [
"NewMockAccessTokenStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/access_token_storage.go#L28-L32 |
151,854 | ory/fosite | compose/config.go | GetScopeStrategy | func (c *Config) GetScopeStrategy() fosite.ScopeStrategy {
if c.ScopeStrategy == nil {
c.ScopeStrategy = fosite.WildcardScopeStrategy
}
return c.ScopeStrategy
} | go | func (c *Config) GetScopeStrategy() fosite.ScopeStrategy {
if c.ScopeStrategy == nil {
c.ScopeStrategy = fosite.WildcardScopeStrategy
}
return c.ScopeStrategy
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetScopeStrategy",
"(",
")",
"fosite",
".",
"ScopeStrategy",
"{",
"if",
"c",
".",
"ScopeStrategy",
"==",
"nil",
"{",
"c",
".",
"ScopeStrategy",
"=",
"fosite",
".",
"WildcardScopeStrategy",
"\n",
"}",
"\n",
"return",
"c",
".",
"ScopeStrategy",
"\n",
"}"
] | // GetScopeStrategy returns the scope strategy to be used. Defaults to glob scope strategy. | [
"GetScopeStrategy",
"returns",
"the",
"scope",
"strategy",
"to",
"be",
"used",
".",
"Defaults",
"to",
"glob",
"scope",
"strategy",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L92-L97 |
151,855 | ory/fosite | compose/config.go | GetAudienceStrategy | func (c *Config) GetAudienceStrategy() fosite.AudienceMatchingStrategy {
if c.AudienceMatchingStrategy == nil {
c.AudienceMatchingStrategy = fosite.DefaultAudienceMatchingStrategy
}
return c.AudienceMatchingStrategy
} | go | func (c *Config) GetAudienceStrategy() fosite.AudienceMatchingStrategy {
if c.AudienceMatchingStrategy == nil {
c.AudienceMatchingStrategy = fosite.DefaultAudienceMatchingStrategy
}
return c.AudienceMatchingStrategy
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetAudienceStrategy",
"(",
")",
"fosite",
".",
"AudienceMatchingStrategy",
"{",
"if",
"c",
".",
"AudienceMatchingStrategy",
"==",
"nil",
"{",
"c",
".",
"AudienceMatchingStrategy",
"=",
"fosite",
".",
"DefaultAudienceMatchingStrategy",
"\n",
"}",
"\n",
"return",
"c",
".",
"AudienceMatchingStrategy",
"\n",
"}"
] | // GetAudienceStrategy returns the scope strategy to be used. Defaults to glob scope strategy. | [
"GetAudienceStrategy",
"returns",
"the",
"scope",
"strategy",
"to",
"be",
"used",
".",
"Defaults",
"to",
"glob",
"scope",
"strategy",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L100-L105 |
151,856 | ory/fosite | compose/config.go | GetAuthorizeCodeLifespan | func (c *Config) GetAuthorizeCodeLifespan() time.Duration {
if c.AuthorizeCodeLifespan == 0 {
return time.Minute * 15
}
return c.AuthorizeCodeLifespan
} | go | func (c *Config) GetAuthorizeCodeLifespan() time.Duration {
if c.AuthorizeCodeLifespan == 0 {
return time.Minute * 15
}
return c.AuthorizeCodeLifespan
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetAuthorizeCodeLifespan",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"c",
".",
"AuthorizeCodeLifespan",
"==",
"0",
"{",
"return",
"time",
".",
"Minute",
"*",
"15",
"\n",
"}",
"\n",
"return",
"c",
".",
"AuthorizeCodeLifespan",
"\n",
"}"
] | // GetAuthorizeCodeLifespan returns how long an authorize code should be valid. Defaults to one fifteen minutes. | [
"GetAuthorizeCodeLifespan",
"returns",
"how",
"long",
"an",
"authorize",
"code",
"should",
"be",
"valid",
".",
"Defaults",
"to",
"one",
"fifteen",
"minutes",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L108-L113 |
151,857 | ory/fosite | compose/config.go | GetIDTokenLifespan | func (c *Config) GetIDTokenLifespan() time.Duration {
if c.IDTokenLifespan == 0 {
return time.Hour
}
return c.IDTokenLifespan
} | go | func (c *Config) GetIDTokenLifespan() time.Duration {
if c.IDTokenLifespan == 0 {
return time.Hour
}
return c.IDTokenLifespan
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetIDTokenLifespan",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"c",
".",
"IDTokenLifespan",
"==",
"0",
"{",
"return",
"time",
".",
"Hour",
"\n",
"}",
"\n",
"return",
"c",
".",
"IDTokenLifespan",
"\n",
"}"
] | // GeIDTokenLifespan returns how long an id token should be valid. Defaults to one hour. | [
"GeIDTokenLifespan",
"returns",
"how",
"long",
"an",
"id",
"token",
"should",
"be",
"valid",
".",
"Defaults",
"to",
"one",
"hour",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L116-L121 |
151,858 | ory/fosite | compose/config.go | GetAccessTokenLifespan | func (c *Config) GetAccessTokenLifespan() time.Duration {
if c.AccessTokenLifespan == 0 {
return time.Hour
}
return c.AccessTokenLifespan
} | go | func (c *Config) GetAccessTokenLifespan() time.Duration {
if c.AccessTokenLifespan == 0 {
return time.Hour
}
return c.AccessTokenLifespan
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetAccessTokenLifespan",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"c",
".",
"AccessTokenLifespan",
"==",
"0",
"{",
"return",
"time",
".",
"Hour",
"\n",
"}",
"\n",
"return",
"c",
".",
"AccessTokenLifespan",
"\n",
"}"
] | // GetAccessTokenLifespan returns how long an access token should be valid. Defaults to one hour. | [
"GetAccessTokenLifespan",
"returns",
"how",
"long",
"an",
"access",
"token",
"should",
"be",
"valid",
".",
"Defaults",
"to",
"one",
"hour",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L124-L129 |
151,859 | ory/fosite | compose/config.go | GetRefreshTokenLifespan | func (c *Config) GetRefreshTokenLifespan() time.Duration {
if c.RefreshTokenLifespan == 0 {
return time.Hour * 24 * 30
}
return c.RefreshTokenLifespan
} | go | func (c *Config) GetRefreshTokenLifespan() time.Duration {
if c.RefreshTokenLifespan == 0 {
return time.Hour * 24 * 30
}
return c.RefreshTokenLifespan
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetRefreshTokenLifespan",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"c",
".",
"RefreshTokenLifespan",
"==",
"0",
"{",
"return",
"time",
".",
"Hour",
"*",
"24",
"*",
"30",
"\n",
"}",
"\n",
"return",
"c",
".",
"RefreshTokenLifespan",
"\n",
"}"
] | // GetRefreshTokenLifespan sets how long a refresh token is going to be valid. Defaults to 30 days. Set to -1 for
// refresh tokens that never expire. | [
"GetRefreshTokenLifespan",
"sets",
"how",
"long",
"a",
"refresh",
"token",
"is",
"going",
"to",
"be",
"valid",
".",
"Defaults",
"to",
"30",
"days",
".",
"Set",
"to",
"-",
"1",
"for",
"refresh",
"tokens",
"that",
"never",
"expire",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L133-L138 |
151,860 | ory/fosite | compose/config.go | GetHashCost | func (c *Config) GetHashCost() int {
if c.HashCost == 0 {
return fosite.DefaultBCryptWorkFactor
}
return c.HashCost
} | go | func (c *Config) GetHashCost() int {
if c.HashCost == 0 {
return fosite.DefaultBCryptWorkFactor
}
return c.HashCost
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetHashCost",
"(",
")",
"int",
"{",
"if",
"c",
".",
"HashCost",
"==",
"0",
"{",
"return",
"fosite",
".",
"DefaultBCryptWorkFactor",
"\n",
"}",
"\n",
"return",
"c",
".",
"HashCost",
"\n",
"}"
] | // GetHashCost returns the bcrypt cost factor. Defaults to 12. | [
"GetHashCost",
"returns",
"the",
"bcrypt",
"cost",
"factor",
".",
"Defaults",
"to",
"12",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L141-L146 |
151,861 | ory/fosite | compose/config.go | GetJWKSFetcherStrategy | func (c *Config) GetJWKSFetcherStrategy() fosite.JWKSFetcherStrategy {
if c.JWKSFetcher == nil {
c.JWKSFetcher = fosite.NewDefaultJWKSFetcherStrategy()
}
return c.JWKSFetcher
} | go | func (c *Config) GetJWKSFetcherStrategy() fosite.JWKSFetcherStrategy {
if c.JWKSFetcher == nil {
c.JWKSFetcher = fosite.NewDefaultJWKSFetcherStrategy()
}
return c.JWKSFetcher
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetJWKSFetcherStrategy",
"(",
")",
"fosite",
".",
"JWKSFetcherStrategy",
"{",
"if",
"c",
".",
"JWKSFetcher",
"==",
"nil",
"{",
"c",
".",
"JWKSFetcher",
"=",
"fosite",
".",
"NewDefaultJWKSFetcherStrategy",
"(",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"JWKSFetcher",
"\n",
"}"
] | // GetJWKSFetcherStrategy returns the JWKSFetcherStrategy. | [
"GetJWKSFetcherStrategy",
"returns",
"the",
"JWKSFetcherStrategy",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L149-L154 |
151,862 | ory/fosite | compose/config.go | GetRedirectSecureChecker | func (c *Config) GetRedirectSecureChecker() func(*url.URL) bool {
if c.RedirectSecureChecker == nil {
return fosite.IsRedirectURISecure
}
return c.RedirectSecureChecker
} | go | func (c *Config) GetRedirectSecureChecker() func(*url.URL) bool {
if c.RedirectSecureChecker == nil {
return fosite.IsRedirectURISecure
}
return c.RedirectSecureChecker
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetRedirectSecureChecker",
"(",
")",
"func",
"(",
"*",
"url",
".",
"URL",
")",
"bool",
"{",
"if",
"c",
".",
"RedirectSecureChecker",
"==",
"nil",
"{",
"return",
"fosite",
".",
"IsRedirectURISecure",
"\n",
"}",
"\n",
"return",
"c",
".",
"RedirectSecureChecker",
"\n",
"}"
] | // GetTokenEntropy returns the entropy of the "message" part of a HMAC Token. Defaults to 32. | [
"GetTokenEntropy",
"returns",
"the",
"entropy",
"of",
"the",
"message",
"part",
"of",
"a",
"HMAC",
"Token",
".",
"Defaults",
"to",
"32",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/config.go#L165-L170 |
151,863 | ory/fosite | internal/introspector.go | NewMockTokenIntrospector | func NewMockTokenIntrospector(ctrl *gomock.Controller) *MockTokenIntrospector {
mock := &MockTokenIntrospector{ctrl: ctrl}
mock.recorder = &MockTokenIntrospectorMockRecorder{mock}
return mock
} | go | func NewMockTokenIntrospector(ctrl *gomock.Controller) *MockTokenIntrospector {
mock := &MockTokenIntrospector{ctrl: ctrl}
mock.recorder = &MockTokenIntrospectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockTokenIntrospector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockTokenIntrospector",
"{",
"mock",
":=",
"&",
"MockTokenIntrospector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockTokenIntrospectorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockTokenIntrospector creates a new mock instance | [
"NewMockTokenIntrospector",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/introspector.go#L28-L32 |
151,864 | ory/fosite | internal/introspector.go | IntrospectToken | func (m *MockTokenIntrospector) IntrospectToken(arg0 context.Context, arg1 string, arg2 fosite.TokenType, arg3 fosite.AccessRequester, arg4 []string) (fosite.TokenType, error) {
ret := m.ctrl.Call(m, "IntrospectToken", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(fosite.TokenType)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockTokenIntrospector) IntrospectToken(arg0 context.Context, arg1 string, arg2 fosite.TokenType, arg3 fosite.AccessRequester, arg4 []string) (fosite.TokenType, error) {
ret := m.ctrl.Call(m, "IntrospectToken", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(fosite.TokenType)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockTokenIntrospector",
")",
"IntrospectToken",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"string",
",",
"arg2",
"fosite",
".",
"TokenType",
",",
"arg3",
"fosite",
".",
"AccessRequester",
",",
"arg4",
"[",
"]",
"string",
")",
"(",
"fosite",
".",
"TokenType",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"fosite",
".",
"TokenType",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // IntrospectToken mocks base method | [
"IntrospectToken",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/introspector.go#L40-L45 |
151,865 | ory/fosite | internal/introspector.go | IntrospectToken | func (mr *MockTokenIntrospectorMockRecorder) IntrospectToken(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntrospectToken", reflect.TypeOf((*MockTokenIntrospector)(nil).IntrospectToken), arg0, arg1, arg2, arg3, arg4)
} | go | func (mr *MockTokenIntrospectorMockRecorder) IntrospectToken(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntrospectToken", reflect.TypeOf((*MockTokenIntrospector)(nil).IntrospectToken), arg0, arg1, arg2, arg3, arg4)
} | [
"func",
"(",
"mr",
"*",
"MockTokenIntrospectorMockRecorder",
")",
"IntrospectToken",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockTokenIntrospector",
")",
"(",
"nil",
")",
".",
"IntrospectToken",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"}"
] | // IntrospectToken indicates an expected call of IntrospectToken | [
"IntrospectToken",
"indicates",
"an",
"expected",
"call",
"of",
"IntrospectToken"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/introspector.go#L48-L50 |
151,866 | ory/fosite | compose/compose_oauth2.go | OAuth2ClientCredentialsGrantFactory | func OAuth2ClientCredentialsGrantFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.ClientCredentialsGrantHandler{
HandleHelper: &oauth2.HandleHelper{
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
AccessTokenStorage: storage.(oauth2.AccessTokenStorage),
AccessTokenLifespan: config.GetAccessTokenLifespan(),
},
ScopeStrategy: config.GetScopeStrategy(),
AudienceMatchingStrategy: config.GetAudienceStrategy(),
}
} | go | func OAuth2ClientCredentialsGrantFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.ClientCredentialsGrantHandler{
HandleHelper: &oauth2.HandleHelper{
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
AccessTokenStorage: storage.(oauth2.AccessTokenStorage),
AccessTokenLifespan: config.GetAccessTokenLifespan(),
},
ScopeStrategy: config.GetScopeStrategy(),
AudienceMatchingStrategy: config.GetAudienceStrategy(),
}
} | [
"func",
"OAuth2ClientCredentialsGrantFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"oauth2",
".",
"ClientCredentialsGrantHandler",
"{",
"HandleHelper",
":",
"&",
"oauth2",
".",
"HandleHelper",
"{",
"AccessTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"AccessTokenStrategy",
")",
",",
"AccessTokenStorage",
":",
"storage",
".",
"(",
"oauth2",
".",
"AccessTokenStorage",
")",
",",
"AccessTokenLifespan",
":",
"config",
".",
"GetAccessTokenLifespan",
"(",
")",
",",
"}",
",",
"ScopeStrategy",
":",
"config",
".",
"GetScopeStrategy",
"(",
")",
",",
"AudienceMatchingStrategy",
":",
"config",
".",
"GetAudienceStrategy",
"(",
")",
",",
"}",
"\n",
"}"
] | // OAuth2ClientCredentialsGrantFactory creates an OAuth2 client credentials grant handler and registers
// an access token, refresh token and authorize code validator. | [
"OAuth2ClientCredentialsGrantFactory",
"creates",
"an",
"OAuth2",
"client",
"credentials",
"grant",
"handler",
"and",
"registers",
"an",
"access",
"token",
"refresh",
"token",
"and",
"authorize",
"code",
"validator",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_oauth2.go#L48-L58 |
151,867 | ory/fosite | compose/compose_oauth2.go | OAuth2RefreshTokenGrantFactory | func OAuth2RefreshTokenGrantFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.RefreshTokenGrantHandler{
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
RefreshTokenStrategy: strategy.(oauth2.RefreshTokenStrategy),
TokenRevocationStorage: storage.(oauth2.TokenRevocationStorage),
AccessTokenLifespan: config.GetAccessTokenLifespan(),
RefreshTokenLifespan: config.GetRefreshTokenLifespan(),
ScopeStrategy: config.GetScopeStrategy(),
AudienceMatchingStrategy: config.GetAudienceStrategy(),
}
} | go | func OAuth2RefreshTokenGrantFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.RefreshTokenGrantHandler{
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
RefreshTokenStrategy: strategy.(oauth2.RefreshTokenStrategy),
TokenRevocationStorage: storage.(oauth2.TokenRevocationStorage),
AccessTokenLifespan: config.GetAccessTokenLifespan(),
RefreshTokenLifespan: config.GetRefreshTokenLifespan(),
ScopeStrategy: config.GetScopeStrategy(),
AudienceMatchingStrategy: config.GetAudienceStrategy(),
}
} | [
"func",
"OAuth2RefreshTokenGrantFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"oauth2",
".",
"RefreshTokenGrantHandler",
"{",
"AccessTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"AccessTokenStrategy",
")",
",",
"RefreshTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"RefreshTokenStrategy",
")",
",",
"TokenRevocationStorage",
":",
"storage",
".",
"(",
"oauth2",
".",
"TokenRevocationStorage",
")",
",",
"AccessTokenLifespan",
":",
"config",
".",
"GetAccessTokenLifespan",
"(",
")",
",",
"RefreshTokenLifespan",
":",
"config",
".",
"GetRefreshTokenLifespan",
"(",
")",
",",
"ScopeStrategy",
":",
"config",
".",
"GetScopeStrategy",
"(",
")",
",",
"AudienceMatchingStrategy",
":",
"config",
".",
"GetAudienceStrategy",
"(",
")",
",",
"}",
"\n",
"}"
] | // OAuth2RefreshTokenGrantFactory creates an OAuth2 refresh grant handler and registers
// an access token, refresh token and authorize code validator. | [
"OAuth2RefreshTokenGrantFactory",
"creates",
"an",
"OAuth2",
"refresh",
"grant",
"handler",
"and",
"registers",
"an",
"access",
"token",
"refresh",
"token",
"and",
"authorize",
"code",
"validator",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_oauth2.go#L62-L72 |
151,868 | ory/fosite | compose/compose_oauth2.go | OAuth2ResourceOwnerPasswordCredentialsFactory | func OAuth2ResourceOwnerPasswordCredentialsFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.ResourceOwnerPasswordCredentialsGrantHandler{
ResourceOwnerPasswordCredentialsGrantStorage: storage.(oauth2.ResourceOwnerPasswordCredentialsGrantStorage),
HandleHelper: &oauth2.HandleHelper{
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
AccessTokenStorage: storage.(oauth2.AccessTokenStorage),
AccessTokenLifespan: config.GetAccessTokenLifespan(),
RefreshTokenLifespan: config.GetRefreshTokenLifespan(),
},
RefreshTokenStrategy: strategy.(oauth2.RefreshTokenStrategy),
ScopeStrategy: config.GetScopeStrategy(),
AudienceMatchingStrategy: config.GetAudienceStrategy(),
}
} | go | func OAuth2ResourceOwnerPasswordCredentialsFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.ResourceOwnerPasswordCredentialsGrantHandler{
ResourceOwnerPasswordCredentialsGrantStorage: storage.(oauth2.ResourceOwnerPasswordCredentialsGrantStorage),
HandleHelper: &oauth2.HandleHelper{
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
AccessTokenStorage: storage.(oauth2.AccessTokenStorage),
AccessTokenLifespan: config.GetAccessTokenLifespan(),
RefreshTokenLifespan: config.GetRefreshTokenLifespan(),
},
RefreshTokenStrategy: strategy.(oauth2.RefreshTokenStrategy),
ScopeStrategy: config.GetScopeStrategy(),
AudienceMatchingStrategy: config.GetAudienceStrategy(),
}
} | [
"func",
"OAuth2ResourceOwnerPasswordCredentialsFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"oauth2",
".",
"ResourceOwnerPasswordCredentialsGrantHandler",
"{",
"ResourceOwnerPasswordCredentialsGrantStorage",
":",
"storage",
".",
"(",
"oauth2",
".",
"ResourceOwnerPasswordCredentialsGrantStorage",
")",
",",
"HandleHelper",
":",
"&",
"oauth2",
".",
"HandleHelper",
"{",
"AccessTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"AccessTokenStrategy",
")",
",",
"AccessTokenStorage",
":",
"storage",
".",
"(",
"oauth2",
".",
"AccessTokenStorage",
")",
",",
"AccessTokenLifespan",
":",
"config",
".",
"GetAccessTokenLifespan",
"(",
")",
",",
"RefreshTokenLifespan",
":",
"config",
".",
"GetRefreshTokenLifespan",
"(",
")",
",",
"}",
",",
"RefreshTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"RefreshTokenStrategy",
")",
",",
"ScopeStrategy",
":",
"config",
".",
"GetScopeStrategy",
"(",
")",
",",
"AudienceMatchingStrategy",
":",
"config",
".",
"GetAudienceStrategy",
"(",
")",
",",
"}",
"\n",
"}"
] | // OAuth2ResourceOwnerPasswordCredentialsFactory creates an OAuth2 resource owner password credentials grant handler and registers
// an access token, refresh token and authorize code validator. | [
"OAuth2ResourceOwnerPasswordCredentialsFactory",
"creates",
"an",
"OAuth2",
"resource",
"owner",
"password",
"credentials",
"grant",
"handler",
"and",
"registers",
"an",
"access",
"token",
"refresh",
"token",
"and",
"authorize",
"code",
"validator",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_oauth2.go#L88-L101 |
151,869 | ory/fosite | compose/compose_oauth2.go | OAuth2TokenRevocationFactory | func OAuth2TokenRevocationFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.TokenRevocationHandler{
TokenRevocationStorage: storage.(oauth2.TokenRevocationStorage),
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
RefreshTokenStrategy: strategy.(oauth2.RefreshTokenStrategy),
}
} | go | func OAuth2TokenRevocationFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.TokenRevocationHandler{
TokenRevocationStorage: storage.(oauth2.TokenRevocationStorage),
AccessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
RefreshTokenStrategy: strategy.(oauth2.RefreshTokenStrategy),
}
} | [
"func",
"OAuth2TokenRevocationFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"oauth2",
".",
"TokenRevocationHandler",
"{",
"TokenRevocationStorage",
":",
"storage",
".",
"(",
"oauth2",
".",
"TokenRevocationStorage",
")",
",",
"AccessTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"AccessTokenStrategy",
")",
",",
"RefreshTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"RefreshTokenStrategy",
")",
",",
"}",
"\n",
"}"
] | // OAuth2TokenRevocationFactory creates an OAuth2 token revocation handler. | [
"OAuth2TokenRevocationFactory",
"creates",
"an",
"OAuth2",
"token",
"revocation",
"handler",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_oauth2.go#L104-L110 |
151,870 | ory/fosite | compose/compose_oauth2.go | OAuth2TokenIntrospectionFactory | func OAuth2TokenIntrospectionFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.CoreValidator{
CoreStrategy: strategy.(oauth2.CoreStrategy),
CoreStorage: storage.(oauth2.CoreStorage),
ScopeStrategy: config.GetScopeStrategy(),
DisableRefreshTokenValidation: config.DisableRefreshTokenValidation,
}
} | go | func OAuth2TokenIntrospectionFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.CoreValidator{
CoreStrategy: strategy.(oauth2.CoreStrategy),
CoreStorage: storage.(oauth2.CoreStorage),
ScopeStrategy: config.GetScopeStrategy(),
DisableRefreshTokenValidation: config.DisableRefreshTokenValidation,
}
} | [
"func",
"OAuth2TokenIntrospectionFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"oauth2",
".",
"CoreValidator",
"{",
"CoreStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"CoreStrategy",
")",
",",
"CoreStorage",
":",
"storage",
".",
"(",
"oauth2",
".",
"CoreStorage",
")",
",",
"ScopeStrategy",
":",
"config",
".",
"GetScopeStrategy",
"(",
")",
",",
"DisableRefreshTokenValidation",
":",
"config",
".",
"DisableRefreshTokenValidation",
",",
"}",
"\n",
"}"
] | // OAuth2TokenIntrospectionFactory creates an OAuth2 token introspection handler and registers
// an access token and refresh token validator. | [
"OAuth2TokenIntrospectionFactory",
"creates",
"an",
"OAuth2",
"token",
"introspection",
"handler",
"and",
"registers",
"an",
"access",
"token",
"and",
"refresh",
"token",
"validator",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_oauth2.go#L114-L121 |
151,871 | ory/fosite | compose/compose_oauth2.go | OAuth2StatelessJWTIntrospectionFactory | func OAuth2StatelessJWTIntrospectionFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.StatelessJWTValidator{
JWTAccessTokenStrategy: strategy.(oauth2.JWTAccessTokenStrategy),
ScopeStrategy: config.GetScopeStrategy(),
}
} | go | func OAuth2StatelessJWTIntrospectionFactory(config *Config, storage interface{}, strategy interface{}) interface{} {
return &oauth2.StatelessJWTValidator{
JWTAccessTokenStrategy: strategy.(oauth2.JWTAccessTokenStrategy),
ScopeStrategy: config.GetScopeStrategy(),
}
} | [
"func",
"OAuth2StatelessJWTIntrospectionFactory",
"(",
"config",
"*",
"Config",
",",
"storage",
"interface",
"{",
"}",
",",
"strategy",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"oauth2",
".",
"StatelessJWTValidator",
"{",
"JWTAccessTokenStrategy",
":",
"strategy",
".",
"(",
"oauth2",
".",
"JWTAccessTokenStrategy",
")",
",",
"ScopeStrategy",
":",
"config",
".",
"GetScopeStrategy",
"(",
")",
",",
"}",
"\n",
"}"
] | // OAuth2StatelessJWTIntrospectionFactory creates an OAuth2 token introspection handler and
// registers an access token validator. This can only be used to validate JWTs and does so
// statelessly, meaning it uses only the data available in the JWT itself, and does not access the
// storage implementation at all.
//
// Due to the stateless nature of this factory, THE BUILT-IN REVOCATION MECHANISMS WILL NOT WORK.
// If you need revocation, you can validate JWTs statefully, using the other factories. | [
"OAuth2StatelessJWTIntrospectionFactory",
"creates",
"an",
"OAuth2",
"token",
"introspection",
"handler",
"and",
"registers",
"an",
"access",
"token",
"validator",
".",
"This",
"can",
"only",
"be",
"used",
"to",
"validate",
"JWTs",
"and",
"does",
"so",
"statelessly",
"meaning",
"it",
"uses",
"only",
"the",
"data",
"available",
"in",
"the",
"JWT",
"itself",
"and",
"does",
"not",
"access",
"the",
"storage",
"implementation",
"at",
"all",
".",
"Due",
"to",
"the",
"stateless",
"nature",
"of",
"this",
"factory",
"THE",
"BUILT",
"-",
"IN",
"REVOCATION",
"MECHANISMS",
"WILL",
"NOT",
"WORK",
".",
"If",
"you",
"need",
"revocation",
"you",
"can",
"validate",
"JWTs",
"statefully",
"using",
"the",
"other",
"factories",
"."
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/compose/compose_oauth2.go#L130-L135 |
151,872 | ory/fosite | internal/oauth2_strategy.go | NewMockCoreStrategy | func NewMockCoreStrategy(ctrl *gomock.Controller) *MockCoreStrategy {
mock := &MockCoreStrategy{ctrl: ctrl}
mock.recorder = &MockCoreStrategyMockRecorder{mock}
return mock
} | go | func NewMockCoreStrategy(ctrl *gomock.Controller) *MockCoreStrategy {
mock := &MockCoreStrategy{ctrl: ctrl}
mock.recorder = &MockCoreStrategyMockRecorder{mock}
return mock
} | [
"func",
"NewMockCoreStrategy",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCoreStrategy",
"{",
"mock",
":=",
"&",
"MockCoreStrategy",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCoreStrategyMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockCoreStrategy creates a new mock instance | [
"NewMockCoreStrategy",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_strategy.go#L28-L32 |
151,873 | ory/fosite | internal/oauth2_storage.go | NewMockCoreStorage | func NewMockCoreStorage(ctrl *gomock.Controller) *MockCoreStorage {
mock := &MockCoreStorage{ctrl: ctrl}
mock.recorder = &MockCoreStorageMockRecorder{mock}
return mock
} | go | func NewMockCoreStorage(ctrl *gomock.Controller) *MockCoreStorage {
mock := &MockCoreStorage{ctrl: ctrl}
mock.recorder = &MockCoreStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockCoreStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCoreStorage",
"{",
"mock",
":=",
"&",
"MockCoreStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCoreStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockCoreStorage creates a new mock instance | [
"NewMockCoreStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_storage.go#L28-L32 |
151,874 | ory/fosite | internal/oauth2_storage.go | CreateRefreshTokenSession | func (mr *MockCoreStorageMockRecorder) CreateRefreshTokenSession(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRefreshTokenSession", reflect.TypeOf((*MockCoreStorage)(nil).CreateRefreshTokenSession), arg0, arg1, arg2)
} | go | func (mr *MockCoreStorageMockRecorder) CreateRefreshTokenSession(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRefreshTokenSession", reflect.TypeOf((*MockCoreStorage)(nil).CreateRefreshTokenSession), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockCoreStorageMockRecorder",
")",
"CreateRefreshTokenSession",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCoreStorage",
")",
"(",
"nil",
")",
".",
"CreateRefreshTokenSession",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // CreateRefreshTokenSession indicates an expected call of CreateRefreshTokenSession | [
"CreateRefreshTokenSession",
"indicates",
"an",
"expected",
"call",
"of",
"CreateRefreshTokenSession"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_storage.go#L71-L73 |
151,875 | ory/fosite | internal/oauth2_storage.go | DeleteAccessTokenSession | func (m *MockCoreStorage) DeleteAccessTokenSession(arg0 context.Context, arg1 string) error {
ret := m.ctrl.Call(m, "DeleteAccessTokenSession", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockCoreStorage) DeleteAccessTokenSession(arg0 context.Context, arg1 string) error {
ret := m.ctrl.Call(m, "DeleteAccessTokenSession", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreStorage",
")",
"DeleteAccessTokenSession",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // DeleteAccessTokenSession mocks base method | [
"DeleteAccessTokenSession",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_storage.go#L76-L80 |
151,876 | ory/fosite | internal/storage.go | NewMockStorage | func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
mock := &MockStorage{ctrl: ctrl}
mock.recorder = &MockStorageMockRecorder{mock}
return mock
} | go | func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
mock := &MockStorage{ctrl: ctrl}
mock.recorder = &MockStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockStorage",
"{",
"mock",
":=",
"&",
"MockStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockStorage creates a new mock instance | [
"NewMockStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/storage.go#L28-L32 |
151,877 | ory/fosite | internal/refresh_token_strategy.go | NewMockRefreshTokenStrategy | func NewMockRefreshTokenStrategy(ctrl *gomock.Controller) *MockRefreshTokenStrategy {
mock := &MockRefreshTokenStrategy{ctrl: ctrl}
mock.recorder = &MockRefreshTokenStrategyMockRecorder{mock}
return mock
} | go | func NewMockRefreshTokenStrategy(ctrl *gomock.Controller) *MockRefreshTokenStrategy {
mock := &MockRefreshTokenStrategy{ctrl: ctrl}
mock.recorder = &MockRefreshTokenStrategyMockRecorder{mock}
return mock
} | [
"func",
"NewMockRefreshTokenStrategy",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRefreshTokenStrategy",
"{",
"mock",
":=",
"&",
"MockRefreshTokenStrategy",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRefreshTokenStrategyMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockRefreshTokenStrategy creates a new mock instance | [
"NewMockRefreshTokenStrategy",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/refresh_token_strategy.go#L28-L32 |
151,878 | ory/fosite | internal/refresh_token_strategy.go | GenerateRefreshToken | func (mr *MockRefreshTokenStrategyMockRecorder) GenerateRefreshToken(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRefreshToken", reflect.TypeOf((*MockRefreshTokenStrategy)(nil).GenerateRefreshToken), arg0, arg1)
} | go | func (mr *MockRefreshTokenStrategyMockRecorder) GenerateRefreshToken(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRefreshToken", reflect.TypeOf((*MockRefreshTokenStrategy)(nil).GenerateRefreshToken), arg0, arg1)
} | [
"func",
"(",
"mr",
"*",
"MockRefreshTokenStrategyMockRecorder",
")",
"GenerateRefreshToken",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRefreshTokenStrategy",
")",
"(",
"nil",
")",
".",
"GenerateRefreshToken",
")",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // GenerateRefreshToken indicates an expected call of GenerateRefreshToken | [
"GenerateRefreshToken",
"indicates",
"an",
"expected",
"call",
"of",
"GenerateRefreshToken"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/refresh_token_strategy.go#L49-L51 |
151,879 | ory/fosite | internal/oauth2_owner_storage.go | NewMockResourceOwnerPasswordCredentialsGrantStorage | func NewMockResourceOwnerPasswordCredentialsGrantStorage(ctrl *gomock.Controller) *MockResourceOwnerPasswordCredentialsGrantStorage {
mock := &MockResourceOwnerPasswordCredentialsGrantStorage{ctrl: ctrl}
mock.recorder = &MockResourceOwnerPasswordCredentialsGrantStorageMockRecorder{mock}
return mock
} | go | func NewMockResourceOwnerPasswordCredentialsGrantStorage(ctrl *gomock.Controller) *MockResourceOwnerPasswordCredentialsGrantStorage {
mock := &MockResourceOwnerPasswordCredentialsGrantStorage{ctrl: ctrl}
mock.recorder = &MockResourceOwnerPasswordCredentialsGrantStorageMockRecorder{mock}
return mock
} | [
"func",
"NewMockResourceOwnerPasswordCredentialsGrantStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockResourceOwnerPasswordCredentialsGrantStorage",
"{",
"mock",
":=",
"&",
"MockResourceOwnerPasswordCredentialsGrantStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockResourceOwnerPasswordCredentialsGrantStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockResourceOwnerPasswordCredentialsGrantStorage creates a new mock instance | [
"NewMockResourceOwnerPasswordCredentialsGrantStorage",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_owner_storage.go#L28-L32 |
151,880 | ory/fosite | internal/oauth2_owner_storage.go | Authenticate | func (mr *MockResourceOwnerPasswordCredentialsGrantStorageMockRecorder) Authenticate(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Authenticate", reflect.TypeOf((*MockResourceOwnerPasswordCredentialsGrantStorage)(nil).Authenticate), arg0, arg1, arg2)
} | go | func (mr *MockResourceOwnerPasswordCredentialsGrantStorageMockRecorder) Authenticate(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Authenticate", reflect.TypeOf((*MockResourceOwnerPasswordCredentialsGrantStorage)(nil).Authenticate), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockResourceOwnerPasswordCredentialsGrantStorageMockRecorder",
")",
"Authenticate",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockResourceOwnerPasswordCredentialsGrantStorage",
")",
"(",
"nil",
")",
".",
"Authenticate",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // Authenticate indicates an expected call of Authenticate | [
"Authenticate",
"indicates",
"an",
"expected",
"call",
"of",
"Authenticate"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/oauth2_owner_storage.go#L47-L49 |
151,881 | ory/fosite | internal/authorize_handler.go | NewMockAuthorizeEndpointHandler | func NewMockAuthorizeEndpointHandler(ctrl *gomock.Controller) *MockAuthorizeEndpointHandler {
mock := &MockAuthorizeEndpointHandler{ctrl: ctrl}
mock.recorder = &MockAuthorizeEndpointHandlerMockRecorder{mock}
return mock
} | go | func NewMockAuthorizeEndpointHandler(ctrl *gomock.Controller) *MockAuthorizeEndpointHandler {
mock := &MockAuthorizeEndpointHandler{ctrl: ctrl}
mock.recorder = &MockAuthorizeEndpointHandlerMockRecorder{mock}
return mock
} | [
"func",
"NewMockAuthorizeEndpointHandler",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAuthorizeEndpointHandler",
"{",
"mock",
":=",
"&",
"MockAuthorizeEndpointHandler",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAuthorizeEndpointHandlerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAuthorizeEndpointHandler creates a new mock instance | [
"NewMockAuthorizeEndpointHandler",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_handler.go#L28-L32 |
151,882 | ory/fosite | internal/authorize_handler.go | HandleAuthorizeEndpointRequest | func (m *MockAuthorizeEndpointHandler) HandleAuthorizeEndpointRequest(arg0 context.Context, arg1 fosite.AuthorizeRequester, arg2 fosite.AuthorizeResponder) error {
ret := m.ctrl.Call(m, "HandleAuthorizeEndpointRequest", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockAuthorizeEndpointHandler) HandleAuthorizeEndpointRequest(arg0 context.Context, arg1 fosite.AuthorizeRequester, arg2 fosite.AuthorizeResponder) error {
ret := m.ctrl.Call(m, "HandleAuthorizeEndpointRequest", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeEndpointHandler",
")",
"HandleAuthorizeEndpointRequest",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"fosite",
".",
"AuthorizeRequester",
",",
"arg2",
"fosite",
".",
"AuthorizeResponder",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // HandleAuthorizeEndpointRequest mocks base method | [
"HandleAuthorizeEndpointRequest",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_handler.go#L40-L44 |
151,883 | ory/fosite | internal/authorize_handler.go | HandleAuthorizeEndpointRequest | func (mr *MockAuthorizeEndpointHandlerMockRecorder) HandleAuthorizeEndpointRequest(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAuthorizeEndpointRequest", reflect.TypeOf((*MockAuthorizeEndpointHandler)(nil).HandleAuthorizeEndpointRequest), arg0, arg1, arg2)
} | go | func (mr *MockAuthorizeEndpointHandlerMockRecorder) HandleAuthorizeEndpointRequest(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAuthorizeEndpointRequest", reflect.TypeOf((*MockAuthorizeEndpointHandler)(nil).HandleAuthorizeEndpointRequest), arg0, arg1, arg2)
} | [
"func",
"(",
"mr",
"*",
"MockAuthorizeEndpointHandlerMockRecorder",
")",
"HandleAuthorizeEndpointRequest",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAuthorizeEndpointHandler",
")",
"(",
"nil",
")",
".",
"HandleAuthorizeEndpointRequest",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // HandleAuthorizeEndpointRequest indicates an expected call of HandleAuthorizeEndpointRequest | [
"HandleAuthorizeEndpointRequest",
"indicates",
"an",
"expected",
"call",
"of",
"HandleAuthorizeEndpointRequest"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_handler.go#L47-L49 |
151,884 | ory/fosite | internal/authorize_response.go | NewMockAuthorizeResponder | func NewMockAuthorizeResponder(ctrl *gomock.Controller) *MockAuthorizeResponder {
mock := &MockAuthorizeResponder{ctrl: ctrl}
mock.recorder = &MockAuthorizeResponderMockRecorder{mock}
return mock
} | go | func NewMockAuthorizeResponder(ctrl *gomock.Controller) *MockAuthorizeResponder {
mock := &MockAuthorizeResponder{ctrl: ctrl}
mock.recorder = &MockAuthorizeResponderMockRecorder{mock}
return mock
} | [
"func",
"NewMockAuthorizeResponder",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAuthorizeResponder",
"{",
"mock",
":=",
"&",
"MockAuthorizeResponder",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAuthorizeResponderMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAuthorizeResponder creates a new mock instance | [
"NewMockAuthorizeResponder",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L27-L31 |
151,885 | ory/fosite | internal/authorize_response.go | AddFragment | func (m *MockAuthorizeResponder) AddFragment(arg0, arg1 string) {
m.ctrl.Call(m, "AddFragment", arg0, arg1)
} | go | func (m *MockAuthorizeResponder) AddFragment(arg0, arg1 string) {
m.ctrl.Call(m, "AddFragment", arg0, arg1)
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeResponder",
")",
"AddFragment",
"(",
"arg0",
",",
"arg1",
"string",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // AddFragment mocks base method | [
"AddFragment",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L39-L41 |
151,886 | ory/fosite | internal/authorize_response.go | AddHeader | func (m *MockAuthorizeResponder) AddHeader(arg0, arg1 string) {
m.ctrl.Call(m, "AddHeader", arg0, arg1)
} | go | func (m *MockAuthorizeResponder) AddHeader(arg0, arg1 string) {
m.ctrl.Call(m, "AddHeader", arg0, arg1)
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeResponder",
")",
"AddHeader",
"(",
"arg0",
",",
"arg1",
"string",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // AddHeader mocks base method | [
"AddHeader",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L49-L51 |
151,887 | ory/fosite | internal/authorize_response.go | AddQuery | func (m *MockAuthorizeResponder) AddQuery(arg0, arg1 string) {
m.ctrl.Call(m, "AddQuery", arg0, arg1)
} | go | func (m *MockAuthorizeResponder) AddQuery(arg0, arg1 string) {
m.ctrl.Call(m, "AddQuery", arg0, arg1)
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeResponder",
")",
"AddQuery",
"(",
"arg0",
",",
"arg1",
"string",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // AddQuery mocks base method | [
"AddQuery",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L59-L61 |
151,888 | ory/fosite | internal/authorize_response.go | AddQuery | func (mr *MockAuthorizeResponderMockRecorder) AddQuery(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddQuery", reflect.TypeOf((*MockAuthorizeResponder)(nil).AddQuery), arg0, arg1)
} | go | func (mr *MockAuthorizeResponderMockRecorder) AddQuery(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddQuery", reflect.TypeOf((*MockAuthorizeResponder)(nil).AddQuery), arg0, arg1)
} | [
"func",
"(",
"mr",
"*",
"MockAuthorizeResponderMockRecorder",
")",
"AddQuery",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAuthorizeResponder",
")",
"(",
"nil",
")",
".",
"AddQuery",
")",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // AddQuery indicates an expected call of AddQuery | [
"AddQuery",
"indicates",
"an",
"expected",
"call",
"of",
"AddQuery"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L64-L66 |
151,889 | ory/fosite | internal/authorize_response.go | GetCode | func (m *MockAuthorizeResponder) GetCode() string {
ret := m.ctrl.Call(m, "GetCode")
ret0, _ := ret[0].(string)
return ret0
} | go | func (m *MockAuthorizeResponder) GetCode() string {
ret := m.ctrl.Call(m, "GetCode")
ret0, _ := ret[0].(string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeResponder",
")",
"GetCode",
"(",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetCode mocks base method | [
"GetCode",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L69-L73 |
151,890 | ory/fosite | internal/authorize_response.go | GetFragment | func (m *MockAuthorizeResponder) GetFragment() url.Values {
ret := m.ctrl.Call(m, "GetFragment")
ret0, _ := ret[0].(url.Values)
return ret0
} | go | func (m *MockAuthorizeResponder) GetFragment() url.Values {
ret := m.ctrl.Call(m, "GetFragment")
ret0, _ := ret[0].(url.Values)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeResponder",
")",
"GetFragment",
"(",
")",
"url",
".",
"Values",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"url",
".",
"Values",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetFragment mocks base method | [
"GetFragment",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L81-L85 |
151,891 | ory/fosite | internal/authorize_response.go | GetHeader | func (m *MockAuthorizeResponder) GetHeader() http.Header {
ret := m.ctrl.Call(m, "GetHeader")
ret0, _ := ret[0].(http.Header)
return ret0
} | go | func (m *MockAuthorizeResponder) GetHeader() http.Header {
ret := m.ctrl.Call(m, "GetHeader")
ret0, _ := ret[0].(http.Header)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAuthorizeResponder",
")",
"GetHeader",
"(",
")",
"http",
".",
"Header",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"http",
".",
"Header",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetHeader mocks base method | [
"GetHeader",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L93-L97 |
151,892 | ory/fosite | internal/authorize_response.go | GetQuery | func (mr *MockAuthorizeResponderMockRecorder) GetQuery() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQuery", reflect.TypeOf((*MockAuthorizeResponder)(nil).GetQuery))
} | go | func (mr *MockAuthorizeResponderMockRecorder) GetQuery() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQuery", reflect.TypeOf((*MockAuthorizeResponder)(nil).GetQuery))
} | [
"func",
"(",
"mr",
"*",
"MockAuthorizeResponderMockRecorder",
")",
"GetQuery",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAuthorizeResponder",
")",
"(",
"nil",
")",
".",
"GetQuery",
")",
")",
"\n",
"}"
] | // GetQuery indicates an expected call of GetQuery | [
"GetQuery",
"indicates",
"an",
"expected",
"call",
"of",
"GetQuery"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/authorize_response.go#L112-L114 |
151,893 | ory/fosite | token/jwt/claims.go | ToString | func ToString(i interface{}) string {
if i == nil {
return ""
}
if s, ok := i.(string); ok {
return s
}
if sl, ok := i.([]string); ok {
if len(sl) == 1 {
return sl[0]
}
}
return ""
} | go | func ToString(i interface{}) string {
if i == nil {
return ""
}
if s, ok := i.(string); ok {
return s
}
if sl, ok := i.([]string); ok {
if len(sl) == 1 {
return sl[0]
}
}
return ""
} | [
"func",
"ToString",
"(",
"i",
"interface",
"{",
"}",
")",
"string",
"{",
"if",
"i",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"s",
",",
"ok",
":=",
"i",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n\n",
"if",
"sl",
",",
"ok",
":=",
"i",
".",
"(",
"[",
"]",
"string",
")",
";",
"ok",
"{",
"if",
"len",
"(",
"sl",
")",
"==",
"1",
"{",
"return",
"sl",
"[",
"0",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ToString will return a string representation of a map | [
"ToString",
"will",
"return",
"a",
"string",
"representation",
"of",
"a",
"map"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/claims.go#L34-L50 |
151,894 | ory/fosite | token/jwt/claims.go | ToTime | func ToTime(i interface{}) time.Time {
if i == nil {
return time.Time{}
}
if t, ok := i.(int64); ok {
return time.Unix(t, 0).UTC()
} else if t, ok := i.(float64); ok {
return time.Unix(int64(t), 0).UTC()
} else if t, ok := i.(time.Time); ok {
return t
}
return time.Time{}
} | go | func ToTime(i interface{}) time.Time {
if i == nil {
return time.Time{}
}
if t, ok := i.(int64); ok {
return time.Unix(t, 0).UTC()
} else if t, ok := i.(float64); ok {
return time.Unix(int64(t), 0).UTC()
} else if t, ok := i.(time.Time); ok {
return t
}
return time.Time{}
} | [
"func",
"ToTime",
"(",
"i",
"interface",
"{",
"}",
")",
"time",
".",
"Time",
"{",
"if",
"i",
"==",
"nil",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"t",
",",
"ok",
":=",
"i",
".",
"(",
"int64",
")",
";",
"ok",
"{",
"return",
"time",
".",
"Unix",
"(",
"t",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}",
"else",
"if",
"t",
",",
"ok",
":=",
"i",
".",
"(",
"float64",
")",
";",
"ok",
"{",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"t",
")",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}",
"else",
"if",
"t",
",",
"ok",
":=",
"i",
".",
"(",
"time",
".",
"Time",
")",
";",
"ok",
"{",
"return",
"t",
"\n",
"}",
"\n\n",
"return",
"time",
".",
"Time",
"{",
"}",
"\n",
"}"
] | // ToTime will try to convert a given input to a time.Time structure | [
"ToTime",
"will",
"try",
"to",
"convert",
"a",
"given",
"input",
"to",
"a",
"time",
".",
"Time",
"structure"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/claims.go#L53-L67 |
151,895 | ory/fosite | token/jwt/claims.go | Filter | func Filter(elements map[string]interface{}, keys ...string) map[string]interface{} {
var keyIdx = make(map[string]bool)
var result = make(map[string]interface{})
for _, key := range keys {
keyIdx[key] = true
}
for k, e := range elements {
if _, ok := keyIdx[k]; !ok {
result[k] = e
}
}
return result
} | go | func Filter(elements map[string]interface{}, keys ...string) map[string]interface{} {
var keyIdx = make(map[string]bool)
var result = make(map[string]interface{})
for _, key := range keys {
keyIdx[key] = true
}
for k, e := range elements {
if _, ok := keyIdx[k]; !ok {
result[k] = e
}
}
return result
} | [
"func",
"Filter",
"(",
"elements",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"keys",
"...",
"string",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"var",
"keyIdx",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"var",
"result",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"keyIdx",
"[",
"key",
"]",
"=",
"true",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"e",
":=",
"range",
"elements",
"{",
"if",
"_",
",",
"ok",
":=",
"keyIdx",
"[",
"k",
"]",
";",
"!",
"ok",
"{",
"result",
"[",
"k",
"]",
"=",
"e",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] | // Filter will filter out elemets based on keys in a given input map na key-slice | [
"Filter",
"will",
"filter",
"out",
"elemets",
"based",
"on",
"keys",
"in",
"a",
"given",
"input",
"map",
"na",
"key",
"-",
"slice"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/claims.go#L70-L85 |
151,896 | ory/fosite | token/jwt/claims.go | Copy | func Copy(elements map[string]interface{}) (result map[string]interface{}) {
result = make(map[string]interface{}, len(elements))
for k, v := range elements {
result[k] = v
}
return result
} | go | func Copy(elements map[string]interface{}) (result map[string]interface{}) {
result = make(map[string]interface{}, len(elements))
for k, v := range elements {
result[k] = v
}
return result
} | [
"func",
"Copy",
"(",
"elements",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"result",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"result",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"elements",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"elements",
"{",
"result",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] | // Copy will copy all elements in a map and return a new representational map | [
"Copy",
"will",
"copy",
"all",
"elements",
"in",
"a",
"map",
"and",
"return",
"a",
"new",
"representational",
"map"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/token/jwt/claims.go#L88-L95 |
151,897 | ory/fosite | internal/request.go | NewMockRequester | func NewMockRequester(ctrl *gomock.Controller) *MockRequester {
mock := &MockRequester{ctrl: ctrl}
mock.recorder = &MockRequesterMockRecorder{mock}
return mock
} | go | func NewMockRequester(ctrl *gomock.Controller) *MockRequester {
mock := &MockRequester{ctrl: ctrl}
mock.recorder = &MockRequesterMockRecorder{mock}
return mock
} | [
"func",
"NewMockRequester",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRequester",
"{",
"mock",
":=",
"&",
"MockRequester",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRequesterMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockRequester creates a new mock instance | [
"NewMockRequester",
"creates",
"a",
"new",
"mock",
"instance"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/request.go#L29-L33 |
151,898 | ory/fosite | internal/request.go | GetSession | func (m *MockRequester) GetSession() fosite.Session {
ret := m.ctrl.Call(m, "GetSession")
ret0, _ := ret[0].(fosite.Session)
return ret0
} | go | func (m *MockRequester) GetSession() fosite.Session {
ret := m.ctrl.Call(m, "GetSession")
ret0, _ := ret[0].(fosite.Session)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRequester",
")",
"GetSession",
"(",
")",
"fosite",
".",
"Session",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"fosite",
".",
"Session",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetSession mocks base method | [
"GetSession",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/request.go#L147-L151 |
151,899 | ory/fosite | internal/request.go | Sanitize | func (m *MockRequester) Sanitize(arg0 []string) fosite.Requester {
ret := m.ctrl.Call(m, "Sanitize", arg0)
ret0, _ := ret[0].(fosite.Requester)
return ret0
} | go | func (m *MockRequester) Sanitize(arg0 []string) fosite.Requester {
ret := m.ctrl.Call(m, "Sanitize", arg0)
ret0, _ := ret[0].(fosite.Requester)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRequester",
")",
"Sanitize",
"(",
"arg0",
"[",
"]",
"string",
")",
"fosite",
".",
"Requester",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"fosite",
".",
"Requester",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Sanitize mocks base method | [
"Sanitize",
"mocks",
"base",
"method"
] | 27bbe0033273157ea449310c064675127e2550e6 | https://github.com/ory/fosite/blob/27bbe0033273157ea449310c064675127e2550e6/internal/request.go#L189-L193 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.