Diff of the two buildlogs: -- --- b1/build.log 2024-11-15 17:34:24.317908332 +0000 +++ b2/build.log 2024-11-15 17:35:33.746746429 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Thu Dec 18 11:56:39 -12 2025 -I: pbuilder-time-stamp: 1766102199 +I: Current time: Sat Nov 16 07:34:26 +14 2024 +I: pbuilder-time-stamp: 1731692066 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/unstable-reproducible-base.tgz] I: copying local configuration @@ -32,54 +32,86 @@ dpkg-source: info: applying update-test-expectations.patch I: Not using root during the build. I: Installing the build-deps -I: user script /srv/workspace/pbuilder/119924/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/D01_modify_environment starting +debug: Running on ionos12-i386. +I: Changing host+domainname to test build reproducibility +I: Adding a custom variable just for the fun of it... +I: Changing /bin/sh to bash +'/bin/sh' -> '/bin/bash' +lrwxrwxrwx 1 root root 9 Nov 15 17:34 /bin/sh -> /bin/bash +I: Setting pbuilder2's login shell to /bin/bash +I: Setting pbuilder2's GECOS to second user,second room,second work-phone,second home-phone,second other +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/D02_print_environment starting I: set - BUILDDIR='/build/reproducible-path' - BUILDUSERGECOS='first user,first room,first work-phone,first home-phone,first other' - BUILDUSERNAME='pbuilder1' - BUILD_ARCH='i386' - DEBIAN_FRONTEND='noninteractive' - DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=22 ' - DISTRIBUTION='unstable' - HOME='/root' - HOST_ARCH='i386' + BASH=/bin/sh + BASHOPTS=checkwinsize:cmdhist:complete_fullquote:extquote:force_fignore:globasciiranges:globskipdots:hostcomplete:interactive_comments:patsub_replacement:progcomp:promptvars:sourcepath + BASH_ALIASES=() + BASH_ARGC=() + BASH_ARGV=() + BASH_CMDS=() + BASH_LINENO=([0]="12" [1]="0") + BASH_LOADABLES_PATH=/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:. + BASH_SOURCE=([0]="/tmp/hooks/D02_print_environment" [1]="/tmp/hooks/D02_print_environment") + BASH_VERSINFO=([0]="5" [1]="2" [2]="32" [3]="1" [4]="release" [5]="i686-pc-linux-gnu") + BASH_VERSION='5.2.32(1)-release' + BUILDDIR=/build/reproducible-path + BUILDUSERGECOS='second user,second room,second work-phone,second home-phone,second other' + BUILDUSERNAME=pbuilder2 + BUILD_ARCH=i386 + DEBIAN_FRONTEND=noninteractive + DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=10 ' + DIRSTACK=() + DISTRIBUTION=unstable + EUID=0 + FUNCNAME=([0]="Echo" [1]="main") + GROUPS=() + HOME=/root + HOSTNAME=i-capture-the-hostname + HOSTTYPE=i686 + HOST_ARCH=i386 IFS=' ' - INVOCATION_ID='b02dc2ef56e641d293715d5e2443aea2' - LANG='C' - LANGUAGE='en_US:en' - LC_ALL='C' - LD_LIBRARY_PATH='/usr/lib/libeatmydata' - LD_PRELOAD='libeatmydata.so' - MAIL='/var/mail/root' - OPTIND='1' - PATH='/usr/sbin:/usr/bin:/sbin:/bin:/usr/games' - PBCURRENTCOMMANDLINEOPERATION='build' - PBUILDER_OPERATION='build' - PBUILDER_PKGDATADIR='/usr/share/pbuilder' - PBUILDER_PKGLIBDIR='/usr/lib/pbuilder' - PBUILDER_SYSCONFDIR='/etc' - PPID='119924' - PS1='# ' - PS2='> ' + INVOCATION_ID=ad15b96e7bdb421fb6eedbb1c1a2a879 + LANG=C + LANGUAGE=de_CH:de + LC_ALL=C + LD_LIBRARY_PATH=/usr/lib/libeatmydata + LD_PRELOAD=libeatmydata.so + MACHTYPE=i686-pc-linux-gnu + MAIL=/var/mail/root + OPTERR=1 + OPTIND=1 + OSTYPE=linux-gnu + PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path + PBCURRENTCOMMANDLINEOPERATION=build + PBUILDER_OPERATION=build + PBUILDER_PKGDATADIR=/usr/share/pbuilder + PBUILDER_PKGLIBDIR=/usr/lib/pbuilder + PBUILDER_SYSCONFDIR=/etc + PIPESTATUS=([0]="0") + POSIXLY_CORRECT=y + PPID=53943 PS4='+ ' - PWD='/' - SHELL='/bin/bash' - SHLVL='2' - SUDO_COMMAND='/usr/bin/timeout -k 18.1h 18h /usr/bin/ionice -c 3 /usr/bin/nice /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.jYUIWxo3/pbuilderrc_AdlM --distribution unstable --hookdir /etc/pbuilder/first-build-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.jYUIWxo3/b1 --logfile b1/build.log ruby-grape_2.0.0-3.dsc' - SUDO_GID='112' - SUDO_UID='107' - SUDO_USER='jenkins' - TERM='unknown' - TZ='/usr/share/zoneinfo/Etc/GMT+12' - USER='root' - _='/usr/bin/systemd-run' - http_proxy='http://213.165.73.152:3128' + PWD=/ + SHELL=/bin/bash + SHELLOPTS=braceexpand:errexit:hashall:interactive-comments:posix + SHLVL=3 + SUDO_COMMAND='/usr/bin/timeout -k 24.1h 24h /usr/bin/ionice -c 3 /usr/bin/nice -n 11 /usr/bin/unshare --uts -- /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.jYUIWxo3/pbuilderrc_tKsb --distribution unstable --hookdir /etc/pbuilder/rebuild-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.jYUIWxo3/b2 --logfile b2/build.log ruby-grape_2.0.0-3.dsc' + SUDO_GID=112 + SUDO_UID=107 + SUDO_USER=jenkins + TERM=unknown + TZ=/usr/share/zoneinfo/Etc/GMT-14 + UID=0 + USER=root + _='I: set' + http_proxy=http://46.16.76.132:3128 I: uname -a - Linux ionos16-i386 6.1.0-27-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.115-1 (2024-11-01) x86_64 GNU/Linux + Linux i-capture-the-hostname 6.1.0-27-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.115-1 (2024-11-01) x86_64 GNU/Linux I: ls -l /bin - lrwxrwxrwx 1 root root 7 Aug 4 2024 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/119924/tmp/hooks/D02_print_environment finished + lrwxrwxrwx 1 root root 7 Aug 4 21:30 /bin -> usr/bin +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -331,7 +363,7 @@ Get: 180 http://deb.debian.org/debian unstable/main i386 ruby-rspec-mocks all 3.13.0c0e0m0s1-2 [81.3 kB] Get: 181 http://deb.debian.org/debian unstable/main i386 ruby-rspec all 3.13.0c0e0m0s1-2 [5184 B] Get: 182 http://deb.debian.org/debian unstable/main i386 ruby-test-prof all 0.12.2+dfsg-1 [42.8 kB] -Fetched 47.6 MB in 2s (21.5 MB/s) +Fetched 47.6 MB in 1s (50.8 MB/s) debconf: delaying package configuration, since apt-utils is not installed Selecting previously unselected package libpython3.12-minimal:i386. (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 19953 files and directories currently installed.) @@ -937,8 +969,8 @@ Setting up tzdata (2024b-3) ... Current default time zone: 'Etc/UTC' -Local time is now: Thu Dec 18 23:57:01 UTC 2025. -Universal Time is now: Thu Dec 18 23:57:01 UTC 2025. +Local time is now: Fri Nov 15 17:34:58 UTC 2024. +Universal Time is now: Fri Nov 15 17:34:58 UTC 2024. Run 'dpkg-reconfigure tzdata' if you wish to change it. Setting up autotools-dev (20220109.1) ... @@ -1095,7 +1127,11 @@ Building tag database... -> Finished parsing the build-deps I: Building the package -I: Running cd /build/reproducible-path/ruby-grape-2.0.0/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-genchanges -S > ../ruby-grape_2.0.0-3_source.changes +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for unstable +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/A99_set_merged_usr finished +hostname: Name or service not known +I: Running cd /build/reproducible-path/ruby-grape-2.0.0/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-genchanges -S > ../ruby-grape_2.0.0-3_source.changes dpkg-buildpackage: info: source package ruby-grape dpkg-buildpackage: info: source version 2.0.0-3 dpkg-buildpackage: info: source distribution unstable @@ -1132,7 +1168,7 @@ │ ruby-grape: Installing files and building extensions for ruby3.1 │ └──────────────────────────────────────────────────────────────────────────────┘ -/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20251218-125340-9j8rpd/gemspec +/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20241116-59734-5ixud7/gemspec Failed to load /dev/null because it doesn't contain valid YAML hash WARNING: open-ended dependency on activesupport (>= 5) is not recommended if activesupport is semantically versioned, use: @@ -1152,7 +1188,7 @@ Name: grape Version: 2.0.0 File: grape-2.0.0.gem -/usr/bin/ruby3.1 -S gem install --config-file /dev/null --verbose --local --verbose --no-document --ignore-dependencies --install-dir debian/ruby-grape/usr/share/rubygems-integration/all /tmp/d20251218-125340-9j8rpd/grape-2.0.0.gem +/usr/bin/ruby3.1 -S gem install --config-file /dev/null --verbose --local --verbose --no-document --ignore-dependencies --install-dir debian/ruby-grape/usr/share/rubygems-integration/all /tmp/d20241116-59734-5ixud7/grape-2.0.0.gem Failed to load /dev/null because it doesn't contain valid YAML hash /build/reproducible-path/ruby-grape-2.0.0/debian/ruby-grape/usr/share/rubygems-integration/all/gems/grape-2.0.0/lib/grape.rb /build/reproducible-path/ruby-grape-2.0.0/debian/ruby-grape/usr/share/rubygems-integration/all/gems/grape-2.0.0/lib/grape/api.rb @@ -1335,1851 +1371,1082 @@ /usr/share/rubygems-integration/all/gems/dry-equalizer-0.3.0/lib/dry/equalizer.rb:5: warning: previous definition of Equalizer was here /build/reproducible-path/ruby-grape-2.0.0/spec/grape/validations/validators/except_values_spec.rb:10: warning: method redefined; discarding old excepts -Randomized with seed 4865 +Randomized with seed 1404 -Grape::API::Helpers - default - default - private - public - patch - default - public - private - -Grape::Endpoint - get - responds - put - responds +Grape::Http::Headers + is expected to eq "Allow" + is expected to eq "Transfer-Encoding" + is expected to eq "X-Cascade" + is expected to eq "Location" Grape::Endpoint - resets all instance variables (except block) between calls - does not persist params between calls - sets itself in the env upon call - allows explicit return calls - #initialize - takes a settings stack, options, and a block - request - includes version v1 - includes version v1 - is set to the url requested - includes prefix - validation errors - returns the errors, and passes headers - .generate_api_method - raises ArgumentError if a block is not given - returns a Proc - raises NameError if the method name is already in use - #method_missing - when performing an undefined method of an instance inside the API - raises NoMethodError but stripping the internals of the Object class - when referencing an undefined local variable - raises NoMethodError but stripping the internals of the Grape::Endpoint class and including the API route - #params - deeply converts nested params - parses from path segments - is available to the caller - responds with a 415 for an unsupported content-type - does not accept text/plain in JSON format if application/json is specified as content type - with special requirements - parses email param with provided requirements for params - parses many params with provided regexps - namespace requirements - overrides outer namespace's requirements - parse email param with provided requirements for params - from body parameters - converts XML bodies to params - does not convert empty JSON bodies to params - does not include parameters not defined by the body - converts XML bodies to params - converts JSON bodies to params - returns a 400 if given an invalid multipart body - when the limit on multipart files is exceeded - returns a 413 if given too many multipart files - content type with params - does not response with 406 for same type without params - responses with given content type in headers - sets a value to params - params - precedence - route string params have higher precedence than URL params - route string params have higher precedence than body params + #sendfile + returns default + set + as file path + sends no deprecation warnings + does not change the Cache-Control header + returns value wrapped in StreamResponse + does not change the Content-Length header + does not change the Transfer-Encoding header + as object + raises an error that only a file path is supported + #body + returns default + set + returns value + false + sets status to 204 + #stream + returns default + set + as a file path + sets Cache-Control header to no-cache + does not change Cache-Control header + sets Content-Length header to nil + returns file body wrapped in StreamResponse + sets Transfer-Encoding header to nil + emits no deprecation warnings + as a stream object + returns value wrapped in StreamResponse + emits no deprecation warnings + sets Content-Length header to nil + sets Cache-Control header to no-cache + sets Transfer-Encoding header to nil + as a non-stream object + raises an error that the object must implement :each + #declared + is not available by default + #return_no_content + sets the status code and body + #file + get + emits a warning that this method is deprecated +DEPRECATION WARNING: Use sendfile or stream to send files. (called from block (4 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/dsl/inside_route_spec.rb:250) + fowards call to sendfile + set + as object (backward compatibility) +DEPRECATION WARNING: Use stream to use a Stream object. (called from block (5 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/dsl/inside_route_spec.rb:235) + forwards the call to stream + emits a warning that this method is deprecated + as file path +DEPRECATION WARNING: Use sendfile or stream to send files. (called from block (5 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/dsl/inside_route_spec.rb:219) + forwards the call to sendfile + emits a warning that this method is deprecated #redirect - has status code 303 if it is not get request and it is http 1.1 - support permanent redirect - allows for an optional redirect body override - redirects to a url with status 302 - binary -DEPRECATION WARNING: Use stream to use a Stream object. (called from block (4 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/endpoint_spec.rb:1001) - suports stream objects in response - .before_each - is able to stack helper - is able to override a helper - is settable via block - is settable via reference - version headers - result in a 406 response if they are invalid - result in a 406 response if they cannot be parsed by rack-accept - anchoring - delete 204, with empty array has return value (no explicit body) - responds to /example delete method - delete 204, with nil has return value (no explicit body) - responds to /example delete method - delete 200, with response body - responds to /example/and/some/more for the non-anchored delete method - all other - allows for the anchoring option with a PATCH method - responds to /example/and/some/more for the non-anchored GET method - anchors paths by default for the HEAD method - responds to /example/and/some/more for the non-anchored PUT method - responds to /example/and/some/more for the non-anchored OPTIONS method - responds to /example/and/some/more for the non-anchored POST method - responds to /example/and/some/more for the non-anchored PATCH method - anchors paths by default for the PATCH method - allows for the anchoring option with a GET method - responds to /example/and/some/more for the non-anchored HEAD method - allows for the anchoring option with a HEAD method - allows for the anchoring option with a POST method - allows for the anchoring option with a PUT method - anchors paths by default for the GET method - anchors paths by default for the PUT method - anchors paths by default for the POST method - anchors paths by default for the OPTIONS method - allows for the anchoring option with a OPTIONS method - delete 204 - responds to /example/and/some/more for the non-anchored delete method - allows for the anchoring option with a delete method - anchors paths by default for the delete method - delete 200, with a return value (no explicit body) - responds to /example delete method - instrumentation - notifies AS::N - filters - allows adding to response with present - after filters - overrides the response body if it sets it - does not override the response body with its return - before filters - runs the before filter if set - when terminating the response with error! - allows prior and parent filters of same type to run - breaks normal call chain - #status - is callable from within a block - is set as default to 200 for get - is set as default to 201 for post + permanent + sets status to 301 + sets location header + default + sets location header + sets status to 302 + #present + non mergeable entity + instance + fails + multiple entities + instance + presents both dummy objects + dummy + presents dummy object + with + entity + instance + presents dummy object + #route + returns route_info #cookies - sets browser cookies and does not set response cookies - deletes cookies with path - is callable from within a block - sets and update browser cookies - deletes cookie - #params - sets a value to params - params - default class - is a ActiveSupport::HashWithIndifferentAccess - #header - is callable from within a block + returns an instance of Cookies + #content_type + returns default + set + returns value #error! - can specifiy headers - does not merges additional headers with headers set after call - merges additional headers with headers set before call - accepts a message - accepts an object and render it in format - sets the status code for the endpoint - accepts a code - accepts a frozen object - #headers - includes additional request headers - includes headers passed as symbols - includes request headers - -Grape::Validations::Validators::ExceptValuesValidator - 9: req_except_type_coerce - 3 - 11: opt_except_array_type_coerce_default - [10] - 11: opt_except_array_type_coerce_default - 10 - 12: req_except_range - 13 - 7: opt_except_default - invalid-type1 - 8: opt_except_lambda_default - valid-type - 9: req_except_type_coerce - 11 - 2: req_except_custom_message - invalid-type3 - 5: req_except_lambda - invalid-type1 - 11: opt_except_array_type_coerce_default - - 10: opt_except_type_coerce_default - 10 - 8: opt_except_lambda_default - - 7: opt_except_default - valid-type - 10: opt_except_type_coerce_default - invalid-type1 - 11: opt_except_array_type_coerce_default - invalid-type1 - 8: opt_except_lambda_default - invalid-type3 - 9: req_except_type_coerce - invalid-type1 - 1: req_except_hash - invalid-type1 - 5: req_except_lambda - invalid-type4 - 1: req_except_hash - valid-type - 8: opt_except_lambda_default - invalid-type1 - 4: req_except_empty - invalid-type1 - 6: req_except_lambda_custom_message - valid-type - 10: opt_except_type_coerce_default - 3 - 7: opt_except_default - invalid-type3 - 0: req_except - invalid-type3 - 2: req_except_custom_message - invalid-type1 - raises IncompatibleOptionValues when type is incompatible with values array - 5: req_except_lambda - valid-type - 6: req_except_lambda_custom_message - invalid-type4 - 0: req_except - invalid-type1 - 11: opt_except_array_type_coerce_default - [3] - 11: opt_except_array_type_coerce_default - ["3"] - 0: req_except - valid-type - 6: req_except_lambda_custom_message - invalid-type1 - 10: opt_except_type_coerce_default - 3 - 7: opt_except_default - - raises IncompatibleOptionValues on a default value in exclude - 9: req_except_type_coerce - 11 - 9: req_except_type_coerce - 3 - raises IncompatibleOptionValues when a default array has excluded values - 10: opt_except_type_coerce_default - - 2: req_except_custom_message - valid-type - 12: req_except_range - 11 - 1: req_except_hash - invalid-type3 - 3: req_except_no_value - invalid-type1 - -Grape::Exceptions::UnsupportedGroupType - Grape::Exceptions::UnsupportedGroupTypeError - behaves like deprecated class - raises an ActiveSupport::DeprecationException - #message - is expected to include "group type must be Array, Hash, JSON or Array[JSON]" - -Grape::DSL::Helpers - .helpers - adds a module with the given block - uses provided modules - uses many provided modules - in child classes - is available - with an external file - sets Boolean as a Grape::API::Boolean + throws :error + thrown + sets status + default_error_status + sets status to default_error_status + #status + defaults to 201 on POST + defaults to 200 on DELETE with a body present + defaults to 204 on DELETE + defaults to 200 on GET + accepts unknown Integer status codes + returns status set + defaults to 200 on GET + accepts symbol for status + raises error if status is not a integer or symbol + defaults to 200 on GET + raises error if unknow symbol is passed + #version + returns env[api.version] + defaults to nil -Grape::Middleware::Auth::DSL - .http_digest - when realm is a hash - sets auth parameters - when realm is not hash - sets auth parameters - .http_basic - sets auth parameters - .auth - can be called multiple times - sets auth parameters +Grape::Middleware::Auth::Strategies + Basic Auth + throws a 401 if no auth is given + authenticates if given valid creds + throws a 401 is wrong auth is given -Grape::Util::StackableValues - #[]= - sets a value - pushes further values - can handle array values - #clone - copies all values - complex (i.e. not primitive) data types (ex. middleware, please see bug #930) - copies values; does not duplicate them - #[] - parent values are not changed - combines parent and actual values - returns an array of values - returns parent value when no value is set - #delete - deletes a key - does not delete parent values - #to_hash - returns a Hash representation - #keys - returns merged keys with parent - returns all keys +Grape::Middleware::Error + defaults to a 500 status + sets the status code based on the rack util status code symbol + has a default message + sets the error message appropriately + sets the status code appropriately + with http code + adds the status code if wanted + presents an error message -Grape::Middleware::Formatter - send file - returns a file response - no content responses - does not modify a 184 response - does not modify a 181 response - does not modify a 304 response - does not modify a 167 response - does not modify a 160 response - does not modify a 100 response - does not modify a 192 response - does not modify a 124 response - does not modify a 191 response - does not modify a 114 response - does not modify a 172 response - does not modify a 197 response - does not modify a 190 response - does not modify a 188 response - does not modify a 123 response - does not modify a 104 response - does not modify a 148 response - does not modify a 144 response - does not modify a 159 response - does not modify a 147 response - does not modify a 158 response - does not modify a 162 response - does not modify a 127 response - does not modify a 161 response - does not modify a 134 response - does not modify a 198 response - does not modify a 189 response - does not modify a 108 response - does not modify a 136 response - does not modify a 137 response - does not modify a 113 response - does not modify a 110 response - does not modify a 145 response - does not modify a 139 response - does not modify a 169 response - does not modify a 116 response - does not modify a 199 response - does not modify a 166 response - does not modify a 119 response - does not modify a 155 response - does not modify a 153 response - does not modify a 195 response - does not modify a 135 response - does not modify a 182 response - does not modify a 107 response - does not modify a 143 response - does not modify a 106 response - does not modify a 187 response - does not modify a 115 response - does not modify a 128 response - does not modify a 111 response - does not modify a 112 response - does not modify a 138 response - does not modify a 146 response - does not modify a 180 response - does not modify a 122 response - does not modify a 177 response - does not modify a 102 response - does not modify a 141 response - does not modify a 101 response - does not modify a 151 response - does not modify a 163 response - does not modify a 105 response - does not modify a 194 response - does not modify a 150 response - does not modify a 140 response - does not modify a 176 response - does not modify a 118 response - does not modify a 196 response - does not modify a 178 response - does not modify a 129 response - does not modify a 179 response - does not modify a 125 response - does not modify a 156 response - does not modify a 154 response - does not modify a 175 response - does not modify a 165 response - does not modify a 152 response - does not modify a 131 response - does not modify a 157 response - does not modify a 103 response - does not modify a 185 response - does not modify a 109 response - does not modify a 171 response - does not modify a 132 response - does not modify a 186 response - does not modify a 164 response - does not modify a 168 response - does not modify a 130 response - does not modify a 149 response - does not modify a 183 response - does not modify a 126 response - does not modify a 193 response - does not modify a 170 response - does not modify a 204 response - does not modify a 117 response - does not modify a 133 response - does not modify a 142 response - does not modify a 174 response - does not modify a 120 response - does not modify a 121 response - does not modify a 173 response - input - ignores application/x-www-form-urlencoded - ignores application/x-www-form-urlencoded - ignores multipart/form-data - ignores multipart/related - parses the body from an xml PUT and copies values into rack.request.from_hash - ignores multipart/mixed - rewinds IO - parses the body from an xml DELETE and copies values into rack.request.from_hash - ignores multipart/related - parses the chunked body from PATCH and copies values into rack.request.from_hash - ignores multipart/form-data - ignores multipart/mixed - rewinds IO - ignores application/x-www-form-urlencoded - parses the chunked body from DELETE and copies values into rack.request.from_hash - ignores multipart/form-data - rewinds IO - ignores multipart/mixed - ignores multipart/related - ignores multipart/mixed - ignores multipart/related - parses the chunked body from PUT and copies values into rack.request.from_hash - ignores multipart/form-data - parses the chunked body from POST and copies values into rack.request.from_hash - parses the body from an xml PATCH and copies values into rack.request.from_hash - rewinds IO - ignores application/x-www-form-urlencoded - parses the body from an xml POST and copies values into rack.request.from_hash - application/json - parses the body from PUT and copies values into rack.request.form_hash - when body is nil - does not read and parse the body - application/json - parses the body from DELETE and copies values into rack.request.form_hash - application/json; charset=utf-8 - parses the body from PUT and copies values into rack.request.form_hash - when body is not nil or empty - when Content-Type is supported - parses the body from PATCH and copies values into rack.request.form_hash - when Content-Type is not supported - returns a 415 HTTP error status - application/json; charset=utf-8 - parses the body from DELETE and copies values into rack.request.form_hash - when body is not nil or empty - when Content-Type is not supported - returns a 415 HTTP error status - when Content-Type is supported - parses the body from DELETE and copies values into rack.request.form_hash - application/json - parses the body from PATCH and copies values into rack.request.form_hash - when body is empty - does not read and parse the body - when body is empty - does not read and parse the body - when body is empty - does not read and parse the body - application/json; charset=utf-8 - parses the body from POST and copies values into rack.request.form_hash - application/json; charset=utf-8 - parses the body from PATCH and copies values into rack.request.form_hash - when body is nil - does not read and parse the body - when body is nil - does not read and parse the body - application/json - parses the body from POST and copies values into rack.request.form_hash - when body is not nil or empty - when Content-Type is supported - parses the body from PUT and copies values into rack.request.form_hash - when Content-Type is not supported - returns a 415 HTTP error status - when body is not nil or empty - when Content-Type is not supported - returns a 415 HTTP error status - when Content-Type is supported - parses the body from POST and copies values into rack.request.form_hash - when body is nil - does not read and parse the body - when body is empty - does not read and parse the body - custom parser raises exception and rescue options are enabled for backtrace and original_exception - adds the backtrace and original_exception to the error output - serialization - looks at the bodies for possibly serializable data - xml - calls #to_xml if the content type is xml - jsonapi - calls #to_json if the content type is jsonapi - default format - calls #to_json since default format is json - detection - uses the json extension if one is provided - uses the xml extension if one is provided - uses the default format if none is provided - uses the format parameter if one is provided - uses the file extension format if provided before headers - uses the requested format if provided in headers - accept header detection - handles quality rankings that have a default 1.0 value - uses quality rankings to determine formats - parses headers with other attributes - parses headers with vendor and api version - ensures that a quality of 0 is less preferred than any other content type - handles quality rankings mixed with nothing - ignores invalid quality rankings - parses headers with symbols as hash keys - detects from the Accept header - with custom vendored content types - uses the custom type - inheritable formatters - returns response by invalid formatter - content-type - is set for xml - is set for json - is set for vendored with registered type - is set to closest generic for custom vendored/versioned without registered type - is set for txt - is set for custom - format - uses custom json formatter - uses custom formatter - default - uses default json formatter - error handling -caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError - does not rescue other exceptions - rescues formatter-specific exceptions +Grape::Endpoint + parameter renaming + with a deeply nested parameter structure + generates the correct parameter names for documentation + maps no parameters when none are given + does not modify the request params + maps the renamed parameter correctly + with a renamed root parameter + maps the renamed parameter correctly (original name) + generates the correct parameter names for documentation + ignores the renamed parameter (as name) + validates the renamed parameter correctly (original name) + with a renamed hash with nested parameters + ignores the renamed parameter (as name) + maps the renamed parameter correctly (original name) + generates the correct parameter names for documentation + validates the renamed parameter correctly (original name) + with a renamed hash with nested renamed parameter + maps the renamed parameter correctly (original name) + ignores the renamed parameter (as name, 3) + ignores the renamed parameter (as name, 1) + ignores the renamed parameter (as name, 2) + validates the renamed parameter correctly (original name) + generates the correct parameter names for documentation + #declared; mixed nesting + can access parent route_param + #declared + does not include missing attributes if that option is passed + shows nil for multiple allowed types if include_missing is true + does not include missing attributes when there are nested hashes + has as many keys as there are declared params + builds arrays correctly + includes missing attributes with defaults when there are nested hashes + builds nested params when given array + includes attributes with value that evaluates to false + includes attributes with value that evaluates to nil + shows nil for nested params if include_missing is true + has a optional param with default value all the time + does not include renamed missing attributes if that option is passed + builds nested params + stringifies if that option is passed + filters out any additional params that are given + does not work in a before filter + when the param is missing and include_missing=true + sets objects with type=Set to be a set + sets objects with type=Hash to be a hash + includes all declared children when type=Hash + sets objects with type=Array to be an array + when the param is missing and include_missing=false + sets nested objects to be nil + when params are not built with default class +W, [2024-11-16T07:35:17.032739 #59757] WARN -- : You are setting a key that conflicts with a built-in method Hashie::Mash#first defined in Enumerable. This can cause unexpected behavior when accessing the key as a property. You can still access the key via the #[] method. +W, [2024-11-16T07:35:17.033543 #59757] WARN -- : You are setting a key that conflicts with a built-in method Hashie::Mash#first defined in Enumerable. This can cause unexpected behavior when accessing the key as a property. You can still access the key via the #[] method. + returns an object that corresponds with the params class - hashie mash + returns an object that corresponds with the params class - hash + returns an object that corresponds with the params class - hash with indifferent access + #declared; with multiple route_param + return :compositor_id for mounter in route_param + return only :artist_id without :id + return only :id without :artist_id + return :filter and :id parameters in declared for second enpoint inside route_param + #declared; call from child namespace + is expected to eq 200 + with include_parent_namespaces: true + returns declared parameters from every parent namespace + without declaration + returns all requested parameters + with include_parent_namespaces: false + returns declared parameters only from current namespace + #declared; from a nested mounted endpoint + can access parent attributes -Grape::Validations::Types::ArrayCoercer - #call - an array of primitives - coerces elements in the array - an array of arrays - coerces elements in the nested array - an array of sets - coerces elements in the nested set +Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder + in an endpoint + #params + is of type Hash + in an api + #params + is a Hash + responds to string keys + params are indifferent to symbol or string keys + parses sub hash params -Grape::Util::InheritableValues - #delete - does not delete parent values - deletes a key - #[] - returns a value - overwrites parent value with the current one - returns parent value when no value is set - parent values are not changed - #to_hash - returns a Hash representation - #[]= - sets a value - #clone - complex (i.e. not primitive) data types (ex. entity classes, please see bug #891) - copies values; does not duplicate them +Grape::Validations::ParamsScope + returns a sensible error message within a nested context + includes the nested parameter within #declared(params) + raises an error if the dependent parameter was never specified + includes level 2 nested parameters outside the given within #declared(params) + includes deeply nested parameters within #declared(params) + when validations are dependent on a parameter + does not raise an error if when using nested given + returns a sensible error message within a nested context + allows nested dependent parameters + does not raise an error if the dependent parameter is a Hash + allows renaming of dependent on parameter + raises an error if the dependent parameter is the renamed one + does not raise if the dependent parameter is not the renamed one + raises an error if the dependent parameter was never specified + applies only the appropriate validation + allows renaming of dependent parameters + does not validate nested requires when given is false + applies the validations only if the parameter is present + applies the validations of multiple parameters + includes the parameter within #declared(params) + includes the nested parameter within #declared(params) + includes level 2 nested parameters outside the given within #declared(params) + detect unmet nested dependency + when the dependent parameter is not present #declared(params) + nested given parameter within an array param + evaluate_given_false + evaluate_given_true + nested given parameter within a nested given parameter within an array param + evaluate_given_true + evaluate_given_false + lateral parameter + evaluate_given_false + evaluate_given_true + nested given parameter + evaluate_given_false + evaluate_given_true + lateral parameter within an array param + evaluate_given_false + evaluate_given_true + lateral hash parameter + evaluate_given_false + evaluate_given_true + lateral parameter within lateral hash parameter + evaluate_given_true + evaluate_given_false + when validations are dependent on a parameter within an array param within #declared(params).to_json + applies the constraint within each value + when using custom types + coerces the parameter via the type's parse method + coercing values validation with proc +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows the proc to pass validation without checking in except + allows the proc to pass validation without checking + allows the proc to pass validation without checking in value + array without coerce type explicitly given + fails to call API without Array type + raises exception when range values have different endpoint types + sets the type based on first element + raises exception when values are of different type + when validations are dependent on a parameter within an array param + passes none Hash params + when params have group attributes + with several group attributes + when data is invalid + responds with HTTP error + returns a validation error + when correct data is provided + returns a successful response + with validations + when parameter has the same validator as a group + prioritizes parameter validation over group validation + returns a successful response + when data is invalid + applies group validations for every parameter + returns a validation error + with nested groups + when data is invalid + responds with HTTP error + returns a validation error + when correct data is provided + returns a successful response + with types + when created_at receives a valid date + returns a successful response + returns a date + when invalid date provided + returns a validation error + responds with HTTP error + param renaming + is expected to eq 200 + renaming can be defined before default + renaming can be defined after default + is expected to eq "any-any2" + is expected to eq "foo is empty" + is expected to eq "-there we go" + is expected to eq "{\"baz\":{\"qux\":\"any\"}}" + failing fast + when fail_fast is not defined + does not stop validation + when fail_fast is defined it stops the validation + for a single param + of other params + with range values + when the default is an array + and is a subset of allowed values + does not raise an exception + and is the entire range of allowed values + does not raise an exception + when right range endpoint isn't #kind_of? the type + raises exception + when left range endpoint isn't #kind_of? the type + raises exception + when both range endpoints are #kind_of? the type + rejects values outside the range + accepts values in the range + default value in given block + when dependency meets + sets default value for dependent parameter + when dependency does not meet + does not set default value for dependent parameter + when validations are dependent on a parameter with specific value + (case 15) + applies the validation when base param has the specific value + includes the parameter within #declared(params) + skips validation when base param does not have a specified value + (case 2) + includes the parameter within #declared(params) + applies the validation when base param has the specific value + skips validation when base param does not have a specified value + skips validation when base param is missing + (case 3) + includes the parameter within #declared(params) + applies the validation when base param has the specific value + skips validation when base param is missing + skips validation when base param does not have a specified value + (case 9) + applies the validation when base param has the specific value + includes the parameter within #declared(params) + skips validation when base param does not have a specified value + (case 10) + includes the parameter within #declared(params) + skips validation when base param does not have a specified value + applies the validation when base param has the specific value + (case 11) + applies the validation when base param has the specific value + skips validation when base param does not have a specified value + includes the parameter within #declared(params) + (case 7) + applies the validation when base param has the specific value + skips validation when base param is missing + skips validation when base param does not have a specified value + includes the parameter within #declared(params) + (case 4) + applies the validation when base param has the specific value + includes the parameter within #declared(params) + skips validation when base param does not have a specified value + skips validation when base param is missing + (case 0) + skips validation when base param is missing + applies the validation when base param has the specific value + skips validation when base param does not have a specified value + includes the parameter within #declared(params) + (case 8) + skips validation when base param does not have a specified value + includes the parameter within #declared(params) + applies the validation when base param has the specific value + (case 1) + applies the validation when base param has the specific value + includes the parameter within #declared(params) + skips validation when base param is missing + skips validation when base param does not have a specified value + (case 14) + skips validation when base param does not have a specified value + applies the validation when base param has the specific value + includes the parameter within #declared(params) + (case 6) + skips validation when base param does not have a specified value + includes the parameter within #declared(params) + skips validation when base param is missing + applies the validation when base param has the specific value + (case 5) + skips validation when base param is missing + includes the parameter within #declared(params) + applies the validation when base param has the specific value + skips validation when base param does not have a specified value + (case 12) + includes the parameter within #declared(params) + applies the validation when base param has the specific value + skips validation when base param does not have a specified value + (case 13) + applies the validation when base param has the specific value + includes the parameter within #declared(params) + skips validation when base param does not have a specified value + with exactly_one_of validation for optional parameters within an Hash param + when invalid data is provided + returns a failure response + when correct data is provided + returns a successful response + parameters in group + allows Array as type + allows Hash as type + errors when no type is provided + errors with an unsupported type + handles missing optional Array type -Grape::Validations::Validators::Base - #inherited - when validator's underscored name does not end with _validator - registers the custom validator with a short name - when validator's underscored name ends with _validator - registers the custom validator with short name not ending with validator - when validator is anonymous - does not register the validator +Validator with instance variables + passes validation every time -Grape::DSL::Routing - .route - defines a new endpoint - resets validations - marks end of the route - does not duplicate identical endpoints - generates correct endpoint options - .namespace - calls #joined_space_path on Namespace - creates a new namespace with given name and options - .get - delegates to .route - .routes - returns value received from #prepare_routes - when #routes was already called once - does not call prepare_routes again - .group - is alias to #namespace - .do_not_route_options! - sets do not route options option - .prefix - sets a prefix for route - .versions - returns last defined version - .resource - is alias to #namespace - .put - delegates to .route - .options - delegates to .route - .version - sets a version for route - .resources - is alias to #namespace - .segment - is alias to #namespace - .patch - delegates to .route - .mount - mounts multiple routes at once - mounts on a nested path - .head - delegates to .route - .scope - create a scope without affecting the URL - .post - delegates to .route - .delete - delegates to .route - .route_param - does not modify options parameter - calls #namespace with given params - nests requirements option under param name - .do_not_route_head! - sets do not route head option +Grape::Endpoint + put + responds + get + responds without ext + responds with ext Grape::Validations using a custom validator with message_key fails with message - using a custom length validator - specified in the query string - over 140 characters - under 140 characters using a custom request/param validator fail when non-admin user sets an admin field - does not fail when we send admin fields and we are admin does not fail when we send non-admin and admin=false fields only - fails when we send admin fields and we are not admin does not fail when we send non-admin fields only - Grape::Validations::Base - behaves like deprecated class - raises an ActiveSupport::DeprecationException + does not fail when we send admin fields and we are admin + fails when we send admin fields and we are not admin using a custom body-only validator ignores field in query allows field in body + using a custom length validator + over 140 characters + specified in the query string + under 140 characters + Grape::Validations::Base + behaves like deprecated class + raises an ActiveSupport::DeprecationException -Grape::Endpoint - when route modifies param value - param default should not change - -Grape::Endpoint - put - responds - get - responds without ext - responds with ext - -Grape::Middleware::Base - is able to access the response - has the app as an accessor - calls through to the app - #context - allows access to response context - header - is able to set a header - #response - when Rack::Response - header - body - status - returns the memoized Rack::Response instance - when Array - body - returns the memoized Rack::Response instance - status - header - callbacks - calls #after - calls #before - callbacks on error - calls #after - after callback - overwrites application response - after callback with errors - does not overwrite the application response - with patched warnings - does show a warning - options - persists options passed at initialization - defaults - overrides default options when provided - persists the default options - header overwrite - overwrites header by after headers - -Grape::API::Helpers - non overriding subclass - with lack of expected params - returns missing error - given expected params - inherits helpers from a superclass - example subclass - given expected params - inherits helpers from a superclass - with lack of expected params - returns missing error - overriding subclass - given expected params - overrides helpers from a superclass - with lack of expected params - returns missing error - -Grape::Middleware::Versioner::AcceptVersionHeader - succeeds if :strict is set to false - succeeds if :strict is not set - when :strict is set - succeeds if proper header is set - fails with 406 Not Acceptable if header is empty - fails with 406 Not Acceptable if header is not set - when :strict and cascade: false - fails with 406 Not Acceptable if header is empty - fails with 406 Not Acceptable if header is not set - succeeds if proper header is set - api.version - is set - is set if format provided - fails with 406 Not Acceptable if version is not supported - -Grape::Middleware::Versioner::Header - succeeds if :strict is set to false and given an invalid header - succeeds if :strict is not set - succeeds if :strict is set to false - api.format - is nil if not provided - is set - when version is set to v1 - is set - is nil if not provided - when version is set to v1 - is nil if not provided - is set - api.version - is set - fails with 406 Not Acceptable if version is invalid - is set if format provided - with missing vendor option - fails - when multiple versions are specified - succeeds with v1 - succeeds with v2 - fails with another version - when :strict and cascade: false - fails with 406 Not Acceptable if header contains a single invalid accept - fails with 406 Not Acceptable if header is empty - fails with 406 Not Acceptable if header is application/xml - succeeds if proper header is set - fails with 406 Not Acceptable if header is not set - when there are multiple versions with complex vendor specified with rescue_from :all - with header versioned endpoints and a rescue_all block defined - responds correctly to a v2 request - responds correctly to a v1 request - api.vendor - fails with 406 Not Acceptable if vendor is invalid - is set - is set if format provided - when version is set - fails with 406 Not Acceptable if vendor is invalid - is set if format provided - is set - when :strict is set - fails with 406 Not Acceptable if header is not set - fails with 406 Not Acceptable if header is empty - succeeds if proper header is set - api.type and api.subtype - sets type and subtype to first choice of content type if no preference given - sets preferred type and subtype - sets preferred type - -Grape::Middleware::Versioner::Path - provides a nil version if no path is given - sets the API version based on the first path - does not cut the version out of the path - with specified versions as ["v1", "v2"] - throws an error if a non-allowed version is specified - allows versions that have been specified - with prefix, but requested version is not matched - recognizes potential version - with specified versions as [:v1, "v2"] - allows versions that have been specified - throws an error if a non-allowed version is specified - with a pattern - sets the version if it matches - ignores the version if it fails to match - with specified versions as [:v1, :v2] - throws an error if a non-allowed version is specified - allows versions that have been specified - with specified versions as ["v1", :v2] - allows versions that have been specified - throws an error if a non-allowed version is specified - with mount path - recognizes potential version - -Grape::DSL::Desc - .desc - can be set with options and a block - sets a description - can be set with a block +Grape::Validations::Validators::ValuesValidator + validates default value from proc + allows a valid value for a parameter + allows a valid default value + allows values to be a kind of the coerced type in an array + raises IncompatibleOptionValues when except contains a value that is not a kind of the type + rejects all values if values is an empty array + does not allow an invalid value for a parameter + allows numeric string for int value using lambda + does not allow an invalid value for a parameter using lambda + raises IncompatibleOptionValues when values contains a value that is not a kind of the type + allows a proc for values +Error 'comparison of String with 0 failed' raised while validating attribute 'number' + does not allow non-numeric string value for int value using lambda +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows a default value with except + allows a valid default value + validates against values in a proc + raises IncompatibleOptionValues when type is incompatible with values array + does not validate updated values without proc + does not allow an invalid value for a parameter using an endless range + validates against values in an endless range + allows value using lambda + validates against an empty array in a proc + validates default value from proc against values in a proc + allows a blank value when the allow_blank option is true + allows values to be a kind of the coerced type not just an instance of it + raises IncompatibleOptionValues on an invalid default value from proc +Error 'undefined method `>' for nil:NilClass -Grape - .config - is expected to eq {:param_builder=>Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder} + requires :number, type: Integer, values: ->(v) { v > 0 } + ^' raised while validating attribute 'number' + does not allow nil for int value using lambda + does not allow invalid value using lambda + raises IncompatibleOptionValues on an invalid default value + exclude with a standard custom validation message +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + does not allow an invalid value for a parameter + with a custom exclude validation message +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + does not allow an invalid value for a parameter + nil value for a parameter + allows for a required param in child scope + does not allow for root params scope + accepts for an optional param with a list of values + with a custom exclude validation message +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + does not allow an invalid value for a parameter + with a range of values + allows an array of values inside of the range + rejects an array of values if any of them are outside the range + allows a single value inside of the range + rejects a single value outside the range + custom validation using proc +DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects a single invalid value +DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + accepts a single valid value +DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + uses supplied message +DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects an invalid value among valid ones +DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + accepts multiple valid values + when arity is > 1 +Error 'wrong number of arguments (given 1, expected 2)' raised while validating attribute 'input_one' +Error 'wrong number of arguments (given 1, expected 2)' raised while validating attribute 'input_two' + returns an error status code + when proc has an arity of 1 + rejects an invalid value + accepts a valid value + with mixed values and excepts +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows value, but not in except +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects except +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects outside except and outside value + boolean values + rejects a value which is not in the list + allows a value from the list + exclusive excepts with lambda +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows any other value outside excepts when type is included +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows any other value outside excepts +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects values that matches except + with a lambda values + only evaluates values dynamically with each request + chooses default + exclusive excepts +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows any other value outside excepts +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects values that matches except +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects an array of values if any of them matches except +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows any other value outside excepts when type is included + with a custom validation message + does not allow an invalid value for a parameter using lambda + does not allow an invalid value for a parameter + allows a valid value for a parameter + validates against values in a proc + exclusive excepts with lambda and coercion +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + allows any other value outside excepts +DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) + rejects values that matches except Grape::API - .recognize_path - fetches endpoint by given path - returns nil if given path does not match with registered routes - -Grape::Middleware::Versioner - recognizes :param - recognizes :accept_version_header - recognizes :header - recognizes :path - -Grape::Validations::Validators::MutualExclusionValidator - #validate! - when custom message is specified - returns a validation error - when no mutually exclusive params are present - does not return a validation error - when mutually exclusive params are nested inside optional hash - when params are passed - returns a validation error with full names of the params - when params are empty - does not return a validation error - when mutually exclusive params are nested inside required hash - returns a validation error with full names of the params - when mutually exclusive params are nested inside array - returns a validation error with full names of the params - when a subset of mutually exclusive params are present - returns a validation error - when mutually exclusive params are deeply nested - returns a validation error with full names of the params - when all mutually exclusive params are present - returns a validation error - mixed with other params - returns a validation error - -Grape::DSL::Callbacks - .after - adds a block to "after" - .before - adds a block to "before" - .before_validation - adds a block to "before_validation" - .after_validation - adds a block to "after_validation" - -Validator with instance variables - passes validation every time + execute first request in reasonable time -Grape::DSL::Parameters - #at_least_one_of - adds an at least one of parameter validation - #optional - adds an optional parameter - #exactly_one_of - adds an exactly of one parameter validation - #params - inherits params from parent - when params argument is not a array or a hash - returns empty hash - when params argument is a hash - returns value for @element key - when params argument is an array of hashes - returns values of each hash for @element key - #group - is alias to #requires - #all_or_none_of - adds an all or none of parameter validation - #use - calls processes associated with named params - raises error when non-existent named param is called - #includes - is alias to #use - #use_scope - is alias to #use - #mutually_exclusive - adds an mutally exclusive parameter validation - #with - creates a scope with group attributes - #requires - adds a required parameter +StrictHashConfiguration + set nested configs -Grape::Validations::Validators::AtLeastOneOfValidator - #validate! - when a subset of restricted params are present - does not return a validation error - when none of the restricted params is selected - returns a validation error - when custom message is specified - returns a validation error - when exactly one of the restricted params is selected - does not return a validation error - when restricted params are nested inside array - when none of them are present - returns a validation error with full names of the params - when at least one of them is present - does not return a validation error - when restricted params are nested inside hash - when at least one of them is present - does not return a validation error - when none of them are present - returns a validation error with full names of the params - when restricted params are deeply nested - when at least one of them is present - does not return a validation error - when none of them are present - returns a validation error with full names of the params - when all restricted params are present - does not return a validation error - mixed with other params - does not return a validation error +MultiXml + uses multi_xml -Grape::Middleware::Error - Non-StandardError exception with a provided rescue handler - custom error response - rescues the exception using the provided handler - default error response - rescues the exception using the default handler - - is possible to specify a different default status code - - does not trap regular error! codes - with defaults - does not trap errors by default - - is possible to specify a custom formatter - - is possible to return hash errors in xml format - - is possible to return errors in xml format - - is possible to return the backtrace and the original exception in xml format - - responds to custom Grape exceptions appropriately - - is possible to return the backtrace and the original exception in txt format - - is possible to return errors in json format - - is possible to return errors in jsonapi format - - is possible to return hash errors in json format - with rescue_all - Non-StandardError exception - does not trap errors other than StandardError - StandardError exception - sets the message appropriately - defaults to a 500 status - with rescue_options :backtrace and :exception set to true - is possible to return the backtrace and the original exception in json format - - is possible to return hash errors in jsonapi format +Grape::Validations::Validators::ExceptValuesValidator + 8: opt_except_lambda_default - valid-type + 11: opt_except_array_type_coerce_default - ["3"] + 7: opt_except_default - valid-type + 0: req_except - valid-type + 11: opt_except_array_type_coerce_default - [10] + 1: req_except_hash - invalid-type1 + 10: opt_except_type_coerce_default - 3 + 11: opt_except_array_type_coerce_default - + 6: req_except_lambda_custom_message - invalid-type4 + 7: opt_except_default - + 10: opt_except_type_coerce_default - 3 + raises IncompatibleOptionValues on a default value in exclude + raises IncompatibleOptionValues when a default array has excluded values + 1: req_except_hash - invalid-type3 + 11: opt_except_array_type_coerce_default - invalid-type1 + 10: opt_except_type_coerce_default - + 8: opt_except_lambda_default - + 12: req_except_range - 13 + 2: req_except_custom_message - invalid-type1 + 0: req_except - invalid-type3 + 2: req_except_custom_message - invalid-type3 + 0: req_except - invalid-type1 + 9: req_except_type_coerce - 11 + 8: opt_except_lambda_default - invalid-type3 + 6: req_except_lambda_custom_message - valid-type + 10: opt_except_type_coerce_default - 10 + raises IncompatibleOptionValues when type is incompatible with values array + 5: req_except_lambda - invalid-type1 + 9: req_except_type_coerce - 11 + 12: req_except_range - 11 + 10: opt_except_type_coerce_default - invalid-type1 + 5: req_except_lambda - invalid-type4 + 9: req_except_type_coerce - invalid-type1 + 9: req_except_type_coerce - 3 + 8: opt_except_lambda_default - invalid-type1 + 7: opt_except_default - invalid-type1 + 7: opt_except_default - invalid-type3 + 3: req_except_no_value - invalid-type1 + 4: req_except_empty - invalid-type1 + 11: opt_except_array_type_coerce_default - [3] + 2: req_except_custom_message - valid-type + 5: req_except_lambda - valid-type + 6: req_except_lambda_custom_message - invalid-type1 + 11: opt_except_array_type_coerce_default - 10 + 1: req_except_hash - valid-type + 9: req_except_type_coerce - 3 -Grape::Util::ReverseStackableValues +Grape::Util::StackableValues #[] returns an array of values - parent values are not changed - combines parent and actual values (actual first) + combines parent and actual values returns parent value when no value is set + parent values are not changed + #delete + does not delete parent values + deletes a key + #keys + returns merged keys with parent + returns all keys #to_hash returns a Hash representation #[]= - pushes further values can handle array values sets a value + pushes further values #clone copies all values complex (i.e. not primitive) data types (ex. middleware, please see bug #930) copies values; does not duplicate them - #delete - deletes a key - does not delete parent values - #keys - returns merged keys with parent - returns all keys -Grape::Exceptions::InvalidAcceptHeader - API with cascade=true and without a rescue handler - that receives - an invalid vendor in the request - behaves like a cascaded request - does not find a matching route - an invalid version in the request - behaves like a cascaded request - does not find a matching route - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - API with cascade=true and rescue_from :all handler - that receives - an invalid vendor in the request - behaves like a cascaded request - does not find a matching route - an invalid version in the request - behaves like a cascaded request - does not find a matching route - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - API with cascade=false, http_codes but without a rescue handler - that receives - an invalid version in the request - behaves like a not-cascaded request - does not accept the request - does not include the X-Cascade=pass header - an invalid vendor in the request - behaves like a not-cascaded request - does not accept the request - does not include the X-Cascade=pass header - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - API with cascade=false and with rescue_from :all handler and http_codes - that receives - an invalid vendor in the request - behaves like a rescued request - does show rescue handler processing - does not include the X-Cascade=pass header - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - API with cascade=true, http_codes but without a rescue handler - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - that receives - an invalid version in the request - behaves like a cascaded request - does not find a matching route - an invalid vendor in the request - behaves like a cascaded request - does not find a matching route - API with cascade=false and rescue_from :all handler - that receives - an invalid vendor in the request - behaves like a rescued request - does show rescue handler processing - does not include the X-Cascade=pass header - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - API with cascade=true and with rescue_from :all handler and http_codes - that received a request with correct vendor and version - behaves like a valid request - does return with status 200 - does return the expected result - that receives - an invalid vendor in the request - behaves like a cascaded request - does not find a matching route - an invalid version in the request - behaves like a cascaded request - does not find a matching route - API with cascade=false and without a rescue handler - that received a request with correct vendor and version - behaves like a valid request - does return the expected result - does return with status 200 - that receives - an invalid version in the request - behaves like a not-cascaded request - does not accept the request - does not include the X-Cascade=pass header - an invalid vendor in the request - behaves like a not-cascaded request - does not accept the request - does not include the X-Cascade=pass header - -Grape::DSL::Settings - #namespace_inheritable - delegates to get_or_set - inherits values from surrounding namespace - #unset - deletes a key from settings - #unset_namespace_inheritable - delegates to unset - #unset_route_setting - delegates to unset - #get_or_set - returns a value when nil is new value is provided - sets a values - complex scenario - plays well - #global_setting - delegates to get_or_set - #route_setting - sets a value until the next route - delegates to get_or_set - #namespace_stackable - delegates to get_or_set - stacks values from surrounding namespace - #unset_namespace_stackable - delegates to unset - #namespace_setting - delegates to get_or_set - sets a value until the end of a namespace - resets values after leaving nested namespaces - #unset_global_setting - delegates to unset - #within_namespace - calls start and end for a namespace - returns the last result - #unset_api_class_setting - delegates to unset - #api_class_setting - delegates to get_or_set - #unset_namespace_setting - delegates to unset - -Grape::Http::Headers - is expected to eq "Allow" - is expected to eq "X-Cascade" - is expected to eq "Transfer-Encoding" - is expected to eq "Location" - -Grape::Middleware::Globals - calls through to the app - environment - sets the grape.request.headers environment - sets the grape.request.params environment - sets the grape.request environment - -Grape::API - remounting an API - with a defined route - when mounting on namespace - can access the votes in both places - when mounting one instance - can access the endpoint - when mounting twice - can access the votes in both places - with dynamic configuration - a very complex configuration example - when it should not be mounted - gets a response - when should be mounted is nil - gets a response - when the namespace should be mounted - gets a response - when executing a custom block on mount - mounts the endpoints only when configured to do so - on the ParamScope - mounts the endpoint in the location it is configured - on dynamic checks - can read the configuration on lambdas - when the configuration is read in a helper - will use the dynamic configuration on all routes - when the configuration is read within a namespace - will use the dynamic configuration on all routes - when the configuration is part of the arguments of a method - mounts the endpoint in the location it is configured - when the configuration is the value in a key-arg pair - takes the param from the configuration - when the configuration is read within the response block - will use the dynamic configuration on all routes - when executing a standard block within a `mounted` block with all dynamic params - mounts the API and obtains the description and headers definition - when using an expression derived from a configuration - mounts the endpoint with the name - does not mount the endpoint with a null name - when the expression lives in a namespace - mounts the endpoint with the name - does not mount the endpoint with a null name - when mounting an endpoint conditional on a configuration - mounts the endpoints only when configured to do so - when the params are configured via a configuration - when the configured param is my_attr - requires the configured params - on the DescSCope - mounts the endpoint with the appropiate tags - -Grape::API - execute first request in reasonable time - -Grape::Validations::Validators::AllowBlankValidator - valid input - accepts false when boolean allow_blank - accepts empty when boolean allow_blank - allows missing optional strings - accepts empty input when allow_blank is false - accepts empty input - accepts empty when datetime allow_blank - accepts value when time allow_blank - accepts valid input - accepts empty when date allow_blank - accepts empty when symbol allow_blank - allow_blank when Numeric - accepts empty when integer allow_blank - accepts empty when float allow_blank - accepts empty when integer allow_blank - custom validation message - in an optional group - as an optional param - refuses a blank existing value in an existing scope - accepts a missing group, even with a disallwed blank param - accepts a nested missing optional value - as a required param - accepts a nested missing date value - refuses a blank value in an existing group - accepts a missing group, even with a disallwed blank param - with invalid input - refuses empty string - refuses empty string for an optional param - refuses nil - refuses only whitespaces - with valid input - accepts empty when datetime allow_blank - accepts empty input - accepts valid input - accepts empty when date allow_blank - accepts empty input when allow_blank is false - accepts empty when boolean allow_blank - accepts empty when symbol allow_blank - accepts false when boolean allow_blank - allow_blank when Numeric - accepts empty when integer allow_blank - accepts empty when float allow_blank - accepts empty when integer allow_blank - in a required group - as a required param - refuses a blank value in a required existing group - refuses a string value in a required hash group - as an optional param - refuses a string value in an optional hash group - accepts a nested missing value - refuses a blank existing value in an existing scope - invalid input - refuses only whitespaces - refuses empty string - refuses nil - refuses missing - in a required group - as an optional param - accepts a nested missing value - refuses a string value in an optional hash group - refuses a blank existing value in an existing scope - as a required param - refuses a string value in a required hash group - refuses a blank value in a required existing group - in an optional group - as an optional param - accepts a nested missing optional value - accepts a missing group, even with a disallwed blank param - refuses a blank existing value in an existing scope - as a required param - accepts a nested missing date value - refuses a blank value in an existing group - accepts a missing group, even with a disallwed blank param - -Grape::Parser - .parser_for - calls .parsers - returns parser correctly - when parser does not exist +Grape::DSL::Headers + when headers are set + #header + set + returns value + delete + deletes a header key-value pair + get + returns a specifc value + returns all set headers + when no headers are set + #header returns nil - when parser is an instance of Symbol - returns object which can be called - returns an instance of Method - when parser is available - returns registered parser if available - .builtin_parsers - includes json and xml parsers by default - returns an instance of Hash - .parsers - includes built-in parsers - returns an instance of Hash - with :parsers option - includes passed :parsers values - with added parser by using `register` keyword - includes added parser - -Grape::Endpoint - get - no format - invalid format - json format - -Grape::API::Instance - top level setting - does not inherit settings from the superclass (Grape::API::Instance) - when an instance is mounted on the root - can call the instance endpoint - when an instance is the root - can call the instance endpoint - with multiple moutes - responds the correct body at the second instance - does not raise a FrozenError on first instance - responds the correct body at the first instance - does not raise a FrozenError on second instance - -StrictHashConfiguration - set nested configs - -Grape::Util::InheritableSetting - #to_hash - return all settings as a hash - #namespace - uses new values when a new namespace starts - sets a value until the end of a namespace - #namespace_reverse_stackable - works with reverse stackable values - #api_class - is specific to the class - #inherit_from - notifies clones - #route - sets a value until the next route - works with route values - #api_class - is specific to the class - #namespace_stackable - works with stackable values - #point_in_time_copy - decouples namespace values - decouples namespace reverse stackable values - resets point_in_time_copies - decouples namespace stackable values - adds itself to original as clone - decouples namespace inheritable values - decouples route values - #namespace_inheritable - handles different parents - works with inheritable values - #global - sets a global value - sets the global inherited values - overrides global values - handles different parents - -Grape::Exceptions::ValidationErrors - initialize - assigns headers through base class - message - is not repeated - is expected to eq 1 - is expected to include "FooBar is invalid" - api - can return structured json with separate fields - #full_messages - with errors - returns an array with each errors full message - when attributes is an array of symbols - returns an array with an error full message - -Grape::Exceptions::MissingGroupType - #message - is expected to include "group type is required" - Grape::Exceptions::MissingGroupTypeError - behaves like deprecated class - raises an ActiveSupport::DeprecationException - -Grape::Middleware::Stack - #insert_before - raises an error on an invalid index - inserts a middleware before another middleware class - inserts a middleware before an anonymous class given by its superclass - #insert - inserts a middleware class at the integer index - #build - returns a rack builder instance - when @others are present - applies the middleware specs stored in @others - #concat - adds non :use specs to @others - calls +merge_with+ with the :use specs - #merge_with - applies a collection of operations and middlewares - middleware spec with proc declaration exists - properly forwards spec arguments - #insert_after - inserts a middleware after an anonymous class given by its superclass - raises an error on an invalid index - inserts a middleware after another middleware class - #use - pushes a middleware class with arguments onto the stack - pushes a middleware class with block arguments onto the stack - pushes a middleware class onto the stack - -Grape::Validations::ParamsScope::AttributesDoc - #extract_details - tells when attributes are required - does not clean up doc attrs mandatory for validators - cleans up doc attrs needed for documentation only - #document - documentation is enabled - documents attributes - behaves like an optional doc attribute - does not mention it - behaves like an optional doc attribute - does not mention it - nil as a default value - is still documented - false as a default value - is still documented - the description key instead of desc - adds the given description - behaves like an optional doc attribute - does not mention it - behaves like an optional doc attribute - does not mention it - behaves like an optional doc attribute - does not mention it - documentation is disabled - does not document attributes - -Grape::DSL::Middleware - .insert - adds a middleware with the right operation - .use - adds a middleware with the right operation - .middleware - returns the middleware stack - .insert_before - adds a middleware with the right operation - .insert_after - adds a middleware with the right operation - -Grape::API::Helpers - can access helpers from a mounted resource - can access helpers from a mounted resource in a nested resource - -Grape::API::Instance - boolean constant - sets Boolean as a type - Params endpoint type - params type is a boolean - -Grape::Endpoint - put - responds - get - responds without ext - -Grape::Validations::Validators::RegexpValidator - accepts nil - accepts valid input - regexp with array - accepts valid items - refuses inapppopriate items - refuses empty items - refuses nil items - accepts nil instead of array - custom validation message - accepts nil - accepts valid input - regexp with array - accepts valid items - refuses inapppopriate items - refuses empty items - refuses nil items - accepts nil instead of array - with invalid input - refuses inapppopriate - refuses empty - nested regexp with array - refuses inapppopriate - invalid input - refuses inapppopriate - refuses empty - -Grape::API::Helpers - defines parameters - -Grape -/build/reproducible-path/ruby-grape-2.0.0/lib/grape/eager_load.rb:20: warning: possibly useless use of :: in void context - compile! - eager_load! Grape::Validations::Validators::ExactlyOneOfValidator #validate! - when params are deeply nested - returns a validation error with full names of the params + when none of the params are present + returns a validation error + when custom message is specified + returns a validation error when params are nested inside required hash returns a validation error with full names of the params - when params are nested inside array - returns a validation error with full names of the params when exacly one param is present does not return a validation error when params are nested inside optional hash - when params are empty - does not return a validation error when params are passed returns a validation error with full names of the params - when none of the params are present - returns a validation error + when params are empty + does not return a validation error + when params are deeply nested + returns a validation error with full names of the params + when params are nested inside array + returns a validation error with full names of the params when all params are present returns a validation error mixed with other params returns a validation error when a subset of params are present returns a validation error - when custom message is specified - returns a validation error -Grape::Exceptions::UnknownOptions - #message - contains the problem in the message +Grape::DSL::Middleware + .middleware + returns the middleware stack + .insert_after + adds a middleware with the right operation + .use + adds a middleware with the right operation + .insert + adds a middleware with the right operation + .insert_before + adds a middleware with the right operation Grape::API - const_missing - raises an error - .finally - when the ensure block has no exceptions - when an unhandled occurs inside the API call -Grape::API - executes the ensure code - when a handled error occurs inside the API call -Grape::API - executes the ensure code - when no API call is made + custom route helpers on nested APIs + returns an error when the id is bad + returns the given id when it is valid + .scope Grape::API - has not executed the ensure code - when no errors occurs + scopes the various settings + .rescue_from :grape_exceptions Grape::API - executes the ensure code - with a helper + rescues grape exceptions with a user-defined handler Grape::API - has access to the helper - do_not_route_options! + rescues grape exceptions + .version + when not defined Grape::API - does not include OPTIONS in Allow header + returns nil + when defined Grape::API - does not create an OPTIONS route - .logger + returns version value + .route + with desc Grape::API - returns an instance of Logger class by default + returns route description Grape::API - does not unnecessarily retain duplicate setup blocks - with a custom logger - exposes its interaface - .default_format + returns route parameters + plain Grape::API - parses data in default format + provides access to route info + format Grape::API - returns data in default format - .format - :xml + sets content type for error Grape::API - raised :error from middleware + streams the content of the file with stream Grape::API - hash + includes extension in format Grape::API - array + sets content type for xml error Grape::API - string - :serializable_hash + sets content type for txt format Grape::API - root +DEPRECATION WARNING: Use stream to use a Stream object. (called from block (4 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:1243) + returns the content of the file with file Grape::API - instance + sets content type for serializable hash format Grape::API - array - :json + sets content type for json Grape::API - raised :error from middleware + sets content type for json error Grape::API - can be overwritten with an explicit content type + returns raw data when content type binary Grape::API - forces json from a non-accepting header + sets content type for xml Grape::API - forces json without an extension + does not include extension in id Grape::API - does not force json with an extension - :txt + sets content type for binary format Grape::API - forces txt from a non-accepting header + does not set Cache-Control + with a custom content_type Grape::API - does not force txt with an extension + sets content type for error Grape::API - forces txt without an extension - :txt only + sets content type + env["api.format"] Grape::API - accepts specified extension + uploads and downloads a PNG file via /attachment.png Grape::API - does not accept extensions other than specified + uploads and downloads a Ruby file Grape::API - forces txt without an extension + uploads and downloads a PNG file via attachment + .mount + without a hash Grape::API - forces txt from a non-accepting header - .formatter - multiple formatters + calls through setting the route to "/" + mounting an API Grape::API - sets another formatter + mounts on a nested path Grape::API - sets one formatter - custom formatter class + mounts a prefixed API with nested resources Grape::API - uses json + applies format to a mounted API with nested resources Grape::API - uses custom formatter - custom formatter + applies the settings of the mounting api Grape::API - uses json + responds to options with path versioning Grape::API - uses custom formatter - cascading - via endpoint + mounts on a path Grape::API - does not cascade + mounts multiple versioned APIs with nested resources Grape::API - cascades - via version + responds to options Grape::API - cascades + mounts a versioned API with nested resources Grape::API - does not cascade - .default_error_status + collects the routes of the mounted api Grape::API - uses the default error status in error! + applies the settings to nested mounted apis Grape::API - allows setting default_error_status + recognizes potential versions with mounted path Grape::API - has a default error status - .rescue_from klass, rescue_subclasses: boolean + applies auth to a mounted API with nested resources + when including a module + correctlies include module in nested mount + when mounting class extends a subclass of Grape::API + mounts APIs with the same superclass + when some rescues are defined by mounted Grape::API - sets rescue_subclasses to true by default + prefers rescues defined by mounted even if outer is more specific Grape::API - rescues error as well as subclass errors with rescue_subclasses option set + prefers rescues defined by mounted if they rescue similar error class Grape::API - does not rescue child errors if rescue_subclasses is false - .configure + inherits parent rescues Grape::API - allows configuring the api - when not given a block + prefers more specific rescues defined by mounted + with a bare rack app Grape::API - returns a configuration object - when given a block + is able to cascade Grape::API - calls the block passing the config + makes a bare Rack app available at the endpoint Grape::API - returns self - .represent + anchors the routes, passing all subroutes to it + .insert Grape::API - adds the association to the :representations setting + inserts middleware in a specific location in the stack + .call + it does not add to the app setup Grape::API - requires a :with option + calls the app .http_basic Grape::API - can set instance variables accessible to routes + protects any resources on the same scope +Grape::API + has access to helper methods Grape::API is scopable Grape::API has access to the current endpoint Grape::API + can set instance variables accessible to routes +Grape::API is callable via .auth as well + .configure Grape::API - protects any resources on the same scope + allows configuring the api + when given a block Grape::API - has access to helper methods - .mount - without a hash + returns self Grape::API - calls through setting the route to "/" - mounting an API + calls the block passing the config + when not given a block Grape::API - mounts on a path + returns a configuration object + .represent Grape::API - collects the routes of the mounted api + adds the association to the :representations setting Grape::API - mounts multiple versioned APIs with nested resources + requires a :with option + .rescue_from klass, lambda Grape::API - responds to options with path versioning + rescues an error with the lambda Grape::API - recognizes potential versions with mounted path + can execute the lambda with an argument + custom middleware + .insert_before Grape::API - responds to options + runs before a given middleware + .insert_after Grape::API - applies auth to a mounted API with nested resources + runs after a given middleware + .middleware Grape::API - applies format to a mounted API with nested resources + includes middleware arguments from settings Grape::API - mounts on a nested path + includes all middleware from stacked settings + .use Grape::API - applies the settings of the mounting api + adds a block if one is given Grape::API - mounts a versioned API with nested resources + does not destroy the middleware settings on multiple runs Grape::API - applies the settings to nested mounted apis + mounts behind error middleware Grape::API - mounts a prefixed API with nested resources - when some rescues are defined by mounted + calls the middleware Grape::API - prefers rescues defined by mounted even if outer is more specific + uses a block if one is given Grape::API - prefers rescues defined by mounted if they rescue similar error class + adds middleware Grape::API - prefers more specific rescues defined by mounted + does not show up outside the namespace + .finally + when the ensure block has no exceptions + when no API call is made Grape::API - inherits parent rescues - when including a module - correctlies include module in nested mount - when mounting class extends a subclass of Grape::API - mounts APIs with the same superclass - with a bare rack app + has not executed the ensure code + when a handled error occurs inside the API call Grape::API - makes a bare Rack app available at the endpoint + executes the ensure code + when an unhandled occurs inside the API call Grape::API - anchors the routes, passing all subroutes to it + executes the ensure code + when no errors occurs Grape::API - is able to cascade - routes - api with a custom route setting + executes the ensure code + with a helper Grape::API - exposed - empty api structure + has access to the helper + .helpers Grape::API - returns an empty array of routes - single method api structure + allows for modules Grape::API - returns one route - api structure with two versions and a namespace + is accessible from the endpoint Grape::API - sets route paths + is scopable Grape::API - sets a nested namespace + allows multiple calls with modules and blocks Grape::API - returns the latest version set + is reopenable + lifecycle + when the api_call fails validation Grape::API - returns versions + follows the failed_validation cycle (skips after_validation, api_call & after) + when the api_call has a controlled error Grape::API - sets route versions + follows the errored life_cycle (skips after) + when the api_call succeeds Grape::API - sets prefix - api structure with an api without params + follows the standard life_cycle + when the api_call has an exception Grape::API - sets params - api structure with additional parameters + follows the errored life_cycle (skips after) + http_codes Grape::API - splits a string + is used as presenter Grape::API - sets params + presented with + .error_format Grape::API - splits a string with limit - api structure with multiple apis + rescues all errors and return :json with backtrace Grape::API - sets params - status + defaults the error formatter to format Grape::API - can be set to arbitrary Integer value + rescues error! and return txt Grape::API - can be set with a status code symbol - normal class methods - can find the appropiate name - is equal to itself - .endpoints + rescues all errors with a default formatter Grape::API - adds one for each route created - .namespace + rescues all errors and return :json Grape::API - comes after the prefix and version + rescues all errors and return :txt with backtrace Grape::API - cancels itself after the block is over + rescues all errors and return :txt + with + class Grape::API - `.resource` is an alias + returns a custom error format + class +/build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:2447: warning: method redefined; discarding old call +/build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:2470: warning: previous definition of call was here Grape::API - is callable with nil just to push onto the stack + returns a custom error format + with json format Grape::API - is stackable + rescues error! called with a string and returns json Grape::API - `.resources` is an alias + rescues error! called with a hash and returns json Grape::API - accepts path segments correctly + rescues error! called with a symbol and returns json + .rescue_from klass, rescue_subclasses: boolean Grape::API - is retrievable and converted to a path + rescues error as well as subclass errors with rescue_subclasses option set Grape::API - `.group` is an alias + sets rescue_subclasses to true by default Grape::API - `.segment` is an alias - .content_type + does not rescue child errors if rescue_subclasses is false + .parser Grape::API - removes existing content types + parses data in format requested by content-type + custom parser class Grape::API - allows to override content-type + uses custom parser + multi_xml Grape::API - sets additional content-type - .insert + doesn't parse yaml + lambda parser Grape::API - inserts middleware in a specific location in the stack - body - false + uses parser for text/custom Grape::API - returns blank body - plain text + uses parser for text/custom; charset=UTF-8 + none parser class Grape::API - returns blank body - .route_param + does not parse data + .namespace Grape::API - defines requirements with a single hash + `.segment` is an alias Grape::API - adds a parameterized route segment namespace - with param type definitions + `.resources` is an alias Grape::API - is used by passing to options - desc + accepts path segments correctly Grape::API - allows to set the type attribute on :group element + cancels itself after the block is over Grape::API - empty array of routes + comes after the prefix and version Grape::API -DEPRECATION WARNING: /build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:3098: The route_xxx methods such as route_foo have been deprecated, please use foo. (called from method_missing at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/router/route.rb:27) - namespaces and describe arbitrary parameters + `.group` is an alias Grape::API - empty array of routes + is callable with nil just to push onto the stack Grape::API - does not symbolize params + is stackable Grape::API - describes a method with parameters + is retrievable and converted to a path Grape::API - groups nested params and prevents overwriting of params with same name in different groups + `.resource` is an alias + .rescue_from Grape::API - describes methods separately + rescues all errors with a json formatter Grape::API - parses parameters when no description is given + rescues only certain errors if rescue_from is called with specific errors Grape::API - includes details + does not rescue errors when rescue_from is not set Grape::API - does not inherit param descriptions in consequent namespaces +caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError + can rescue exceptions raised in the formatter Grape::API -DEPRECATION WARNING: /build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:3053: The route_xxx methods such as route_foo have been deprecated, please use foo. (called from method_missing at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/router/route.rb:27) - describes a method + rescues all errors if rescue_from :all is called Grape::API - merges the parameters of nested namespaces + uses default_rescue_handler to handle invalid response from rescue_from Grape::API - has params which does not include format and version as named captures + mimics default ruby "rescue" handler Grape::API - resets desc + uses custom helpers defined by using #helpers method + with multiple apis + avoids polluting global namespace + CustomError subclass of Grape::Exceptions::Base Grape::API - merges the parameters of the namespace with the parameters of the method + rescues custom grape exceptions Grape::API - uses full name of parameters in nested groups - with json default_error_formatter + does not re-raise exceptions of type Grape::Exceptions::Base + .content_type Grape::API - returns json error + sets additional content-type +Grape::API + allows to override content-type +Grape::API + removes existing content types + .default_error_status +Grape::API + has a default error status +Grape::API + uses the default error status in error! +Grape::API + allows setting default_error_status .rescue_from klass, block Grape::API rescues Exception custom errors Grape::API - rescues a specific error + rescues a subclass of an error by default Grape::API rescues multiple specific errors Grape::API - does not rescue a different error -Grape::API - rescues a subclass of an error by default + rescues a specific error Grape::API rescues an error via rescue_from :all - .rescue_from :grape_exceptions -Grape::API - rescues grape exceptions Grape::API - rescues grape exceptions with a user-defined handler - .version using path + does not rescue a different error + .version using header behaves like versioning Grape::API - does not overwrite version parameter with API version + is able to specify version as a nesting Grape::API adds the prefix before the API version Grape::API + does not overwrite version parameter with API version +Grape::API is able to specify multiple versions Grape::API sets the API version -Grape::API - is able to specify version as a nesting with before block defined within a version block Grape::API calls before block that is defined within the version block + with different versions for the same endpoint + without a prefix +Grape::API + allows the same endpoint to be implemented + with a prefix +Grape::API + allows the same endpoint to be implemented with catch-all v2 Grape::API @@ -3188,207 +2455,276 @@ finds endpoint v1 Grape::API - finds catch all -Grape::API finds endpoint - with different versions for the same endpoint - without a prefix Grape::API - allows the same endpoint to be implemented - with a prefix -Grape::API - allows the same endpoint to be implemented + finds catch all instance_for_rack + when the app was not mounted +Grape::API + returns the base_instance when the app was mounted Grape::API returns the first mounted instance - when the app was not mounted + .compile! Grape::API - returns the base_instance - do_not_route_head! + requires the grape/eager_load file Grape::API - options does not contain HEAD + compiles the instance for rack! + .compile Grape::API - does not allow HEAD on a GET request - .parser + sets the instance + .prefix Grape::API - parses data in format requested by content-type - multi_xml + disallows POST Grape::API - doesn't parse yaml - lambda parser + supports OPTIONS Grape::API - uses parser for text/custom; charset=UTF-8 + routes through with the prefix Grape::API - uses parser for text/custom - none parser class + routes root through with the prefix + .endpoint Grape::API - does not parse data - custom parser class + path + with non-UTF-8 characters in specified format Grape::API - uses custom parser - .compile! + converts the characters + routes + api structure with additional parameters Grape::API - requires the grape/eager_load file + splits a string Grape::API - compiles the instance for rack! - .version using param - behaves like versioning + sets params Grape::API - adds the prefix before the API version + splits a string with limit + api structure with multiple apis Grape::API - sets the API version + sets params + api with a custom route setting Grape::API - does not overwrite version parameter with API version + exposed + api structure with two versions and a namespace Grape::API - is able to specify multiple versions + sets a nested namespace Grape::API - is able to specify version as a nesting - with before block defined within a version block + sets prefix Grape::API - calls before block that is defined within the version block - with different versions for the same endpoint - without a prefix + sets route paths Grape::API - allows the same endpoint to be implemented - with a prefix + returns the latest version set Grape::API - allows the same endpoint to be implemented - with catch-all - v1 + sets route versions Grape::API - finds endpoint + returns versions + status Grape::API - finds catch all - v2 + can be set to arbitrary Integer value Grape::API - finds endpoint + can be set with a status code symbol + empty api structure Grape::API - finds catch all - .rescue_from klass, lambda + returns an empty array of routes + single method api structure Grape::API - rescues an error with the lambda + returns one route + api structure with an api without params Grape::API - can execute the lambda with an argument - .call - it does not add to the app setup + sets params + normal class methods + is equal to itself + can find the appropiate name + do_not_route_options! Grape::API - calls the app - .route - plain + does not create an OPTIONS route Grape::API - provides access to route info - with desc + does not include OPTIONS in Allow header + body + plain text Grape::API - returns route parameters + returns blank body + false Grape::API - returns route description - .route + returns blank body + .format + :txt Grape::API - 405 responses includes an Content-Type header + forces txt without an extension Grape::API - allows and properly constrain a DELETE method + forces txt from a non-accepting header Grape::API - allows and properly constrain a OPTIONS method + does not force txt with an extension + :json Grape::API - handles empty calls + raised :error from middleware Grape::API - allows and properly constrain a POST method + can be overwritten with an explicit content type Grape::API - allows and properly constrain a PUT method + forces json without an extension Grape::API - allows for multiple verbs + forces json from a non-accepting header Grape::API - returns a 201 response code for POST by default + does not force json with an extension + :xml Grape::API - runs before filter exactly once on 405 bad method + hash Grape::API - runs all filters and body with a custom OPTIONS method + array Grape::API - allows and properly constrain a PATCH method + string Grape::API - allows for :any as a verb + raised :error from middleware + :txt only +Grape::API + accepts specified extension +Grape::API + forces txt from a non-accepting header +Grape::API + does not accept extensions other than specified +Grape::API + forces txt without an extension + :serializable_hash +Grape::API + root +Grape::API + array +Grape::API + instance + with json default_error_formatter +Grape::API + returns json error + .change! +Grape::API + invalidates any compiled instance + cascading + via endpoint +Grape::API + does not cascade +Grape::API + cascades + via version +Grape::API + does not cascade +Grape::API + cascades + const_missing + raises an error + .formatter + custom formatter class +Grape::API + uses json +Grape::API + uses custom formatter + multiple formatters +Grape::API + sets another formatter +Grape::API + sets one formatter + custom formatter +Grape::API + uses custom formatter +Grape::API + uses json + catch-all +Grape::API + anchor=true +Grape::API + anchor=false + .inherited + does not override methods inherited from Class + overriding via composition + allows overriding the hook + overriding within class + allows overriding the hook + do_not_route_head! +Grape::API + options does not contain HEAD +Grape::API + does not allow HEAD on a GET request + .route Grape::API allows for multiple paths Grape::API + allows and properly constrain a PATCH method +Grape::API + returns a 201 response code for POST by default +Grape::API allows for catch-all in a namespace Grape::API - returns a 405 for an unsupported method with an X-Custom-Header + allows for :any as a verb Grape::API - allows for no path + allows for format in namespace with no path Grape::API runs only the before filter on 405 bad method Grape::API - allows and properly constrain a HEAD method + runs before filter exactly once on 405 bad method Grape::API - overwrites the default HEAD request + runs all filters and body with a custom OPTIONS method Grape::API - allows for format in namespace with no path + allows for no path Grape::API - allows and properly constrain a GET method + allows for multiple verbs Grape::API - allows for format without corrupting a param + allows and properly constrain a OPTIONS method Grape::API - 405 responses includes an Allow header specifying supported methods + overwrites the default HEAD request Grape::API - allows for multipart paths - adds an OPTIONS route for namespaced endpoints that + returns a 405 for an unsupported method with an X-Custom-Header Grape::API - has an empty body + allows for multipart paths Grape::API - has no Content-Length + allows and properly constrain a DELETE method Grape::API - has no Content-Type + allows and properly constrain a PUT method Grape::API - calls the inner before filter + 405 responses includes an Allow header specifying supported methods Grape::API - has an Allow header + allows for format without corrupting a param Grape::API - calls the outer before filter + allows and properly constrain a GET method Grape::API - returns a 204 - format + allows and properly constrain a HEAD method Grape::API - allows .txt + allows and properly constrain a POST method Grape::API - allows .json - post + 405 responses includes an Content-Type header Grape::API - stores input in api.request.input + handles empty calls + put Grape::API - allows a(n) TrueClass json object in params + allows a(n) Hash json object in params Grape::API - allows a(n) Integer json object in params + allows a(n) String json object in params Grape::API stores input in api.request.input Grape::API - stores input in api.request.input + allows a(n) NilClass json object in params Grape::API stores input in api.request.input Grape::API - allows a(n) Hash json object in params + allows a(n) Integer json object in params Grape::API - stores input in api.request.input + allows a(n) Symbol json object in params Grape::API stores input in api.request.input Grape::API - allows a(n) Float json object in params -Grape::API - allows a(n) String json object in params + allows a(n) FalseClass json object in params Grape::API - allows a(n) NilClass json object in params + allows a(n) TrueClass json object in params Grape::API - allows a(n) FalseClass json object in params + stores input in api.request.input Grape::API stores input in api.request.input Grape::API - allows a(n) Symbol json object in params + stores input in api.request.input Grape::API allows a(n) Array json object in params Grape::API stores input in api.request.input Grape::API stores input in api.request.input +Grape::API + stores input in api.request.input +Grape::API + allows a(n) Float json object in params chunked transfer encoding Grape::API stores input in api.request.input @@ -3416,99 +2752,29 @@ chunked transfer encoding Grape::API stores input in api.request.input - when a resource routes by POST, GET, PATCH, PUT, and DELETE - it adds an OPTIONS route for namespaced endpoints that -Grape::API - has an empty body -Grape::API - returns a 204 -Grape::API - has an Allow header - when hook behaviour is controlled by attributes on the route - when HEAD is called for the defined GET -Grape::API - responds with 401 because before expectations in before hooks are not met - when HTTP method is defined with attribute -Grape::API - responds with the defined error in the before hook - when HTTP method is defined and the underlying before hook expectation is not met -Grape::API - ends up in the endpoint - when HEAD is called for the defined GET -Grape::API - responds with 200 because before hooks are not called - when HTTP method is defined and everything is like the before hooks expect -Grape::API - ends up in the endpoint - when HTTP method is not defined -Grape::API - responds with a 405 status - adds a 405 Not Allowed route that -Grape::API - returns a 405 -Grape::API - contains error message in body -Grape::API - has a X-Custom-Header -Grape::API - has an Allow header - root routes should work with -Grape::API - unversioned APIs -Grape::API - header versioned APIs with multiple headers -Grape::API - Accept-Version header versioned APIs -Grape::API - header versioned APIs -Grape::API - param versioned APIs - path versioned APIs - when a single version provided -Grape::API - without a format -Grape::API - with a format - when array of versions provided -Grape::API - is expected to eql "root" -Grape::API - is expected to eql "root" - adds an OPTIONS route that -Grape::API - has an Allow header -Grape::API - calls before hook -Grape::API - does not call after_validation hook -Grape::API - returns a 204 + post Grape::API - does not call before_validation hook + allows a(n) Integer json object in params Grape::API - calls after hook + allows a(n) Hash json object in params Grape::API - has no Content-Length + allows a(n) TrueClass json object in params Grape::API - has an empty body + allows a(n) FalseClass json object in params Grape::API - has no Content-Type - allows HEAD on a GET request that + allows a(n) NilClass json object in params Grape::API - returns a 200 + stores input in api.request.input Grape::API - has an empty body - put + allows a(n) Symbol json object in params Grape::API stores input in api.request.input Grape::API - allows a(n) Hash json object in params -Grape::API stores input in api.request.input Grape::API - allows a(n) TrueClass json object in params + stores input in api.request.input Grape::API - allows a(n) Symbol json object in params + stores input in api.request.input Grape::API allows a(n) Array json object in params Grape::API @@ -3518,23 +2784,11 @@ Grape::API stores input in api.request.input Grape::API - allows a(n) Integer json object in params -Grape::API stores input in api.request.input Grape::API - allows a(n) NilClass json object in params -Grape::API allows a(n) Float json object in params Grape::API allows a(n) String json object in params -Grape::API - stores input in api.request.input -Grape::API - stores input in api.request.input -Grape::API - stores input in api.request.input -Grape::API - allows a(n) FalseClass json object in params chunked transfer encoding Grape::API stores input in api.request.input @@ -3562,224 +2816,207 @@ chunked transfer encoding Grape::API stores input in api.request.input - when accessing env -Grape::API - returns a 405 for an unsupported method - when format is xml -Grape::API - returns a 405 for an unsupported method - custom middleware - .insert_before -Grape::API - runs before a given middleware - .middleware -Grape::API - includes all middleware from stacked settings + adds an OPTIONS route that Grape::API - includes middleware arguments from settings - .insert_after + has an Allow header Grape::API - runs after a given middleware - .use + has no Content-Length Grape::API - calls the middleware + has no Content-Type Grape::API - adds a block if one is given + does not call after_validation hook Grape::API - does not show up outside the namespace + does not call before_validation hook Grape::API - mounts behind error middleware + calls after hook Grape::API - adds middleware + returns a 204 Grape::API - uses a block if one is given + calls before hook Grape::API - does not destroy the middleware settings on multiple runs - .rescue_from + has an empty body + when hook behaviour is controlled by attributes on the route + when HTTP method is not defined Grape::API - rescues all errors if rescue_from :all is called + responds with a 405 status + when HTTP method is defined with attribute Grape::API -caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError - can rescue exceptions raised in the formatter + responds with the defined error in the before hook + when HTTP method is defined and everything is like the before hooks expect Grape::API - mimics default ruby "rescue" handler + ends up in the endpoint + when HEAD is called for the defined GET Grape::API - uses default_rescue_handler to handle invalid response from rescue_from + responds with 200 because before hooks are not called + when HTTP method is defined and the underlying before hook expectation is not met Grape::API - rescues all errors with a json formatter + ends up in the endpoint + when HEAD is called for the defined GET Grape::API - rescues only certain errors if rescue_from is called with specific errors + responds with 401 because before expectations in before hooks are not met + allows HEAD on a GET request that Grape::API - does not rescue errors when rescue_from is not set + has an empty body Grape::API - uses custom helpers defined by using #helpers method - CustomError subclass of Grape::Exceptions::Base + returns a 200 + when a resource routes by POST, GET, PATCH, PUT, and DELETE + it adds an OPTIONS route for namespaced endpoints that Grape::API - does not re-raise exceptions of type Grape::Exceptions::Base + returns a 204 Grape::API - rescues custom grape exceptions - with multiple apis - avoids polluting global namespace - http_codes + has an empty body Grape::API - presented with + has an Allow header + adds an OPTIONS route for namespaced endpoints that Grape::API - is used as presenter - .change! + has no Content-Type Grape::API - invalidates any compiled instance - filters + returns a 204 Grape::API - adds a after_validation filter + has no Content-Length Grape::API - adds a after filter + calls the outer before filter Grape::API - adds a before filter to current and child namespaces only + has an empty body Grape::API - calls filters in the correct order + has an Allow header Grape::API - calls all filters when validation passes + calls the inner before filter + adds a 405 Not Allowed route that Grape::API - calls only before filters when validation fails + has a X-Custom-Header Grape::API - adds a before filter - format + returns a 405 Grape::API - sets content type for txt format + contains error message in body Grape::API - does not include extension in id + has an Allow header + root routes should work with Grape::API - sets content type for serializable hash format + header versioned APIs Grape::API - does not set Cache-Control + Accept-Version header versioned APIs Grape::API - sets content type for json + unversioned APIs Grape::API -DEPRECATION WARNING: Use stream to use a Stream object. (called from block (4 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:1243) - returns the content of the file with file + header versioned APIs with multiple headers Grape::API - sets content type for binary format + param versioned APIs + path versioned APIs + when array of versions provided Grape::API - sets content type for error + is expected to eql "root" Grape::API - streams the content of the file with stream + is expected to eql "root" + when a single version provided Grape::API - sets content type for json error + without a format Grape::API - sets content type for xml + with a format + when accessing env Grape::API - sets content type for xml error + returns a 405 for an unsupported method + when format is xml Grape::API - returns raw data when content type binary + returns a 405 for an unsupported method + format Grape::API - includes extension in format - env["api.format"] + allows .json Grape::API - uploads and downloads a Ruby file + allows .txt + .default_format Grape::API - uploads and downloads a PNG file via attachment + parses data in default format Grape::API - uploads and downloads a PNG file via /attachment.png - with a custom content_type + returns data in default format + desc Grape::API - sets content type for error +DEPRECATION WARNING: /build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:3053: The route_xxx methods such as route_foo have been deprecated, please use foo. (called from method_missing at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/router/route.rb:27) + describes a method Grape::API - sets content type - custom route helpers on nested APIs - returns an error when the id is bad - returns the given id when it is valid - catch-all +DEPRECATION WARNING: /build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:3098: The route_xxx methods such as route_foo have been deprecated, please use foo. (called from method_missing at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/router/route.rb:27) + namespaces and describe arbitrary parameters Grape::API - anchor=true + groups nested params and prevents overwriting of params with same name in different groups Grape::API - anchor=false - .version - when defined + resets desc Grape::API - returns version value - when not defined + allows to set the type attribute on :group element Grape::API - returns nil - .prefix + parses parameters when no description is given Grape::API - routes root through with the prefix + empty array of routes Grape::API - supports OPTIONS + uses full name of parameters in nested groups Grape::API - routes through with the prefix + merges the parameters of nested namespaces Grape::API - disallows POST - .inherited - does not override methods inherited from Class - overriding within class - allows overriding the hook - overriding via composition - allows overriding the hook - with unsafe HTML format specified + includes details Grape::API - escapes the HTML - .scope + does not inherit param descriptions in consequent namespaces Grape::API - scopes the various settings - .endpoint + does not symbolize params Grape::API - path - with non-UTF-8 characters in specified format + has params which does not include format and version as named captures Grape::API - converts the characters - .rescue_from klass, with: :method_name + merges the parameters of the namespace with the parameters of the method Grape::API - correctly chooses exception handler if :all handler is specified + describes methods separately Grape::API - aborts if the specified method name does not exist + describes a method with parameters Grape::API - rescues an error with the specified method name - .error_format + empty array of routes + .logger Grape::API - rescues all errors and return :json + does not unnecessarily retain duplicate setup blocks Grape::API - rescues all errors and return :txt with backtrace + returns an instance of Logger class by default + with a custom logger + exposes its interaface + filters Grape::API - rescues all errors and return :json with backtrace + calls all filters when validation passes Grape::API - rescues error! and return txt + adds a before filter Grape::API - rescues all errors with a default formatter + calls only before filters when validation fails Grape::API - rescues all errors and return :txt + adds a after filter Grape::API - defaults the error formatter to format - class + adds a after_validation filter Grape::API - returns a custom error format - with json format + calls filters in the correct order Grape::API - rescues error! called with a string and returns json + adds a before filter to current and child namespaces only + .rescue_from klass, with: :method_name Grape::API - rescues error! called with a hash and returns json + rescues an error with the specified method name Grape::API - rescues error! called with a symbol and returns json - with - class -/build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:2470: warning: method redefined; discarding old call -/build/reproducible-path/ruby-grape-2.0.0/spec/grape/api_spec.rb:2447: warning: previous definition of call was here + correctly chooses exception handler if :all handler is specified Grape::API - returns a custom error format - .version using header + aborts if the specified method name does not exist + .version using path behaves like versioning Grape::API - does not overwrite version parameter with API version + adds the prefix before the API version +Grape::API + sets the API version Grape::API is able to specify version as a nesting Grape::API - sets the API version + does not overwrite version parameter with API version Grape::API is able to specify multiple versions -Grape::API - adds the prefix before the API version with before block defined within a version block Grape::API calls before block that is defined within the version block + with different versions for the same endpoint + without a prefix +Grape::API + allows the same endpoint to be implemented + with a prefix +Grape::API + allows the same endpoint to be implemented with catch-all v2 Grape::API @@ -3788,41 +3025,32 @@ finds endpoint v1 Grape::API - finds catch all -Grape::API finds endpoint - with different versions for the same endpoint - without a prefix -Grape::API - allows the same endpoint to be implemented - with a prefix Grape::API - allows the same endpoint to be implemented - lifecycle - when the api_call succeeds + finds catch all + with unsafe HTML format specified Grape::API - follows the standard life_cycle - when the api_call has an exception + escapes the HTML + .route_param Grape::API - follows the errored life_cycle (skips after) - when the api_call fails validation + adds a parameterized route segment namespace Grape::API - follows the failed_validation cycle (skips after_validation, api_call & after) - when the api_call has a controlled error + defines requirements with a single hash + with param type definitions Grape::API - follows the errored life_cycle (skips after) - .version using accept_version_header + is used by passing to options + .version using param behaves like versioning Grape::API - is able to specify version as a nesting -Grape::API - sets the API version + is able to specify multiple versions Grape::API does not overwrite version parameter with API version Grape::API + is able to specify version as a nesting +Grape::API adds the prefix before the API version Grape::API - is able to specify multiple versions + sets the API version with different versions for the same endpoint with a prefix Grape::API @@ -3836,291 +3064,358 @@ with catch-all v1 Grape::API + finds endpoint +Grape::API finds catch all + v2 Grape::API finds endpoint - v2 Grape::API finds catch all + .version using accept_version_header + behaves like versioning Grape::API - finds endpoint - .compile + is able to specify version as a nesting Grape::API - sets the instance - .helpers + adds the prefix before the API version Grape::API - allows for modules + is able to specify multiple versions Grape::API - is scopable + sets the API version Grape::API - is accessible from the endpoint + does not overwrite version parameter with API version + with different versions for the same endpoint + with a prefix Grape::API - allows multiple calls with modules and blocks + allows the same endpoint to be implemented + without a prefix Grape::API - is reopenable + allows the same endpoint to be implemented + with catch-all + v2 +Grape::API + finds endpoint +Grape::API + finds catch all + v1 +Grape::API + finds endpoint +Grape::API + finds catch all + with before block defined within a version block +Grape::API + calls before block that is defined within the version block + .endpoints +Grape::API + adds one for each route created -Grape::Exceptions::ValidationErrors - api without a rescue handler - with content_type text - can recover from failed body parsing - and with content_type json - can recover from failed body parsing - and with no specific content_type - can recover from failed body parsing - with content_type xml - can recover from failed body parsing - api with rescue_from :grape_exceptions handler - with content_type json - returns body parsing error message - with content_type xml - returns body parsing error message - api with rescue_from :grape_exceptions handler with block - with content_type xml - returns body parsing error message - with content_type json - returns body parsing error message - api with rescue_from :all handler - with content_type xml - can recover from failed body parsing - with no specific content_type - can recover from failed body parsing - with content_type json - can recover from failed body parsing - with content_type text - can recover from failed body parsing +Grape::Endpoint + get + routes to a path with multiple params with dots + routes to namespace and path params with dots, with merged requirements + routes to namespace and path params with dots, with overridden requirements + routes to a namespace param with dots -Grape::Validations::SingleAttributeIterator - #each - when params is an array - yields every single attribute from the list for each of the array elements - when missing optional value - does not yield skipped values - empty values - marks params with empty values - when params is a hash - yields params and every single attribute from the list +Grape::Middleware::Auth::Base + authenticates if given valid creds + throws a 401 is wrong auth is given -Grape::Presenters::Presenter - represent - represent object - present - instance - presents dummy hash - multiple presenter - instance - presents both dummy presenter +A named API + can access the name of the API -Grape::Http::Headers - is expected to eq "Allow" - is expected to eq "X-Cascade" - is expected to eq "Location" - is expected to eq "Transfer-Encoding" +Grape::Validations::Validators::AllowBlankValidator + in an optional group + as an optional param + refuses a blank existing value in an existing scope + accepts a missing group, even with a disallwed blank param + accepts a nested missing optional value + as a required param + refuses a blank value in an existing group + accepts a nested missing date value + accepts a missing group, even with a disallwed blank param + custom validation message + with valid input + accepts empty when date allow_blank + accepts false when boolean allow_blank + accepts empty when boolean allow_blank + accepts empty when symbol allow_blank + accepts empty input + accepts empty when datetime allow_blank + accepts empty input when allow_blank is false + accepts valid input + allow_blank when Numeric + accepts empty when float allow_blank + accepts empty when integer allow_blank + accepts empty when integer allow_blank + in a required group + as an optional param + accepts a nested missing value + refuses a string value in an optional hash group + refuses a blank existing value in an existing scope + as a required param + refuses a string value in a required hash group + refuses a blank value in a required existing group + in an optional group + as an optional param + accepts a missing group, even with a disallwed blank param + refuses a blank existing value in an existing scope + accepts a nested missing optional value + as a required param + refuses a blank value in an existing group + accepts a missing group, even with a disallwed blank param + accepts a nested missing date value + with invalid input + refuses empty string + refuses empty string for an optional param + refuses nil + refuses only whitespaces + valid input + accepts empty when boolean allow_blank + accepts value when time allow_blank + accepts empty when date allow_blank + accepts valid input + accepts empty input when allow_blank is false + allows missing optional strings + accepts empty input + accepts empty when datetime allow_blank + accepts empty when symbol allow_blank + accepts false when boolean allow_blank + allow_blank when Numeric + accepts empty when float allow_blank + accepts empty when integer allow_blank + accepts empty when integer allow_blank + in a required group + as a required param + refuses a string value in a required hash group + refuses a blank value in a required existing group + as an optional param + refuses a blank existing value in an existing scope + accepts a nested missing value + refuses a string value in an optional hash group + invalid input + refuses nil + refuses empty string + refuses missing + refuses only whitespaces -Grape::Validations::Validators::DefaultValidator - sets lambda based defaults at the time of call - set default values for optional params - lets you leave required values nested inside an optional blank - set default values for missing params in the request - allows optional arrays to be omitted - sets default values for grouped arrays - set default values for optional params and allow to use required fields in the same time - set default value for optional param - allows optional arrays with optional params - does not allows faulty optional arrays - optional with nil as value - structures types - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - variant-member-type collections - respects the default value - respects the default value - respects the default value - respects the default value - special types - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - primitive types - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - respects the default value - array with default values and given conditions - applies the default values only if the conditions are met - optional group with defaults - optional array with default value includes optional param with default value - sets default value for optional array if param is not provided - optional array without default value includes optional param with default value - returns nil for optional array if param is not provided - optional hash with default value includes optional param with default value - sets default value from parent defaults for inner param if parent param is not provided - sets default value for optional hash if param is not provided - sets own default value for inner param if parent param is provided - optional hash without default value includes optional param with default value - does not fail even if invalid params is passed to default validator - returns nil for optional hash if param is not provided +MultiJson + uses multi_json (PENDING: Temporarily skipped with xit) -Grape::Validations::Types - ::custom? - returns false if the type's #parse method takes other than one argument - returns false if the type does not respond to :parse - returns true if the type responds to :parse with one argument - ::special? - provides special handling for Rack::Multipart::UploadedFile - provides special handling for File - provides special handling for [JSON] - provides special handling for JSON - special types - when Array[JSON] - is expected to eq Grape::Validations::Types::JsonArray - when File - is expected to eq Grape::Validations::Types::File - when Rack::Multipart::UploadedFile - is expected to eq Grape::Validations::Types::File - when JSON - is expected to eq Grape::Validations::Types::Json - ::build_coercer - has internal cache variables - caches the result of the build_coercer method - ::structure? - recognizes Set as a structure - recognizes Array as a structure - recognizes Hash as a structure - ::primitive? - recognizes Grape::API::Boolean as a primitive - recognizes Time as a primitive - recognizes Symbol as a primitive - identifies unknown types - recognizes DateTime as a primitive - recognizes Float as a primitive - recognizes Integer as a primitive - recognizes Date as a primitive - recognizes Numeric as a primitive - recognizes String as a primitive - recognizes BigDecimal as a primitive +Grape::Validations::Validators::AllOrNoneOfValidator + #validate! + when all restricted params are present + does not return a validation error + mixed with other params + does not return a validation error + when a subset of restricted params are present + returns a validation error + when custom message is specified + returns a validation error + when mutually exclusive params are deeply nested + returns a validation error with full names of the params + when restricted params are nested inside required hash + returns a validation error with full names of the params + when mutually exclusive params are nested inside array + returns a validation error with full names of the params + when no restricted params are present + does not return a validation error -Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder - in an endpoint - #params - is of type Hash - in an api - #params - parses sub hash params - params are indifferent to symbol or string keys - responds to string keys - is a Hash +Grape::DSL::Desc + .desc + sets a description + can be set with a block + can be set with options and a block -Grape::Exceptions::MissingMimeType - #message - contains the resolution in the message - contains the problem in the message +Grape::Util::InheritableSetting + #route + sets a value until the next route + works with route values + #to_hash + return all settings as a hash + #namespace_inheritable + works with inheritable values + handles different parents + #namespace + sets a value until the end of a namespace + uses new values when a new namespace starts + #namespace_reverse_stackable + works with reverse stackable values + #point_in_time_copy + decouples namespace inheritable values + resets point_in_time_copies + decouples namespace stackable values + decouples namespace reverse stackable values + adds itself to original as clone + decouples route values + decouples namespace values + #global + sets the global inherited values + sets a global value + handles different parents + overrides global values + #namespace_stackable + works with stackable values + #inherit_from + notifies clones + #api_class + is specific to the class + #api_class + is specific to the class -Grape::Exceptions::Base - #compose_message - when I18n does not enforce available locales - when the fallback locale is available - returns the translated message - when the fallback locale is not available - returns the translated message - when I18n enforces available locales - when the fallback locale is available - returns the translated message - when the fallback locale is not available - returns the translation string - #to_s - is expected to eq "a_message" - #message - is expected to eq "a_message" +Grape::API + remounting an API + with a defined route + when mounting on namespace + can access the votes in both places + when mounting twice + can access the votes in both places + when mounting one instance + can access the endpoint + with dynamic configuration + when using an expression derived from a configuration + does not mount the endpoint with a null name + mounts the endpoint with the name + when the expression lives in a namespace + does not mount the endpoint with a null name + mounts the endpoint with the name + on the DescSCope + mounts the endpoint with the appropiate tags + when mounting an endpoint conditional on a configuration + mounts the endpoints only when configured to do so + when the configuration is read in a helper + will use the dynamic configuration on all routes + a very complex configuration example + when should be mounted is nil + gets a response + when the namespace should be mounted + gets a response + when it should not be mounted + gets a response + when executing a custom block on mount + mounts the endpoints only when configured to do so + on the ParamScope + mounts the endpoint in the location it is configured + on dynamic checks + can read the configuration on lambdas + when executing a standard block within a `mounted` block with all dynamic params + mounts the API and obtains the description and headers definition + when the configuration is read within the response block + will use the dynamic configuration on all routes + when the configuration is part of the arguments of a method + mounts the endpoint in the location it is configured + when the configuration is the value in a key-arg pair + takes the param from the configuration + when the params are configured via a configuration + when the configured param is my_attr + requires the configured params + when the configuration is read within a namespace + will use the dynamic configuration on all routes Grape::API::Helpers - defines parameters + can access helpers from a mounted resource in a nested resource + can access helpers from a mounted resource -Grape::Exceptions::InvalidVersionerOption +Grape::Validations::Types::SetCoercer + #call + a set of sets of arrays + coerces elements in the nested set + a set of primitives + coerces elements to the set + a set of sets + coerces elements in the nested set + +Grape::DSL::Validations + .params + returns a ParamsScope + evaluates block + .reset_validations! + does not reset documentation description + resets params + resets declared params + resets validations + +Grape::Exceptions::MissingGroupType + #message + is expected to include "group type is required" + Grape::Exceptions::MissingGroupTypeError + behaves like deprecated class + raises an ActiveSupport::DeprecationException + +Grape::Exceptions::UnknownValidator #message contains the problem in the message +Grape::Exceptions::UnsupportedGroupType + Grape::Exceptions::UnsupportedGroupTypeError + behaves like deprecated class + raises an ActiveSupport::DeprecationException + #message + is expected to include "group type must be Array, Hash, JSON or Array[JSON]" + +Grape::API + with a global namespace function + works + +Grape::Middleware::Globals + calls through to the app + environment + sets the grape.request.params environment + sets the grape.request.headers environment + sets the grape.request environment + +Grape::Validations::Validators::PresenceValidator + with a required non-empty string + requires when empty + requires when missing + valid when set + with nested parameters + validates nested parameters + with required parameters and no type + validates name, company + with a required regexp parameter supplied in the POST body + validates id + with a custom type + does not validate their type when it is missing + without validation + does not validate for any params + with multiple parameters per requires + validates for all defined params + with reused parameter documentation once required and once optional + works with required + works with optional + with a custom validation message + requires when missing + valid when set + requires when empty + with triply nested required parameters + validates triple nested parameters + Grape::Validations::Validators::CoerceValidator coerce error on malformed input error on malformed input (Array) - i18n - i18n error on malformed input - gives an english fallback error when default locale message is blank - converter - does not build a coercer multiple times - with a custom validation message - errors on malformed input - on custom coercion rules - still validates type - respects :coerce_with - performs no additional coercion + first-class JSON + doesn't make sense using coerce_with + works when declared optional + parses objects, hashes, and arrays + accepts Array[JSON] shorthand coerces - Integer - Nests integers BigDecimal + Nests integers String Grape::API::Boolean + Integer a custom type coerces the given value returning the InvalidValue instance when invalid uses a custom message added to the invalid value File - Rack::Multipart::UploadedFile File + Rack::Multipart::UploadedFile collection - empty string - primitive types - is coerced to nil for type FalseClass - is coerced to nil for type BigDecimal - is coerced to nil for type Integer - is coerced to nil for type Grape::API::Boolean - is coerced to nil for type Numeric - is coerced to nil for type Date - is coerced to nil for type TrueClass - is coerced to nil for type DateTime - is not coerced to nil for type String - is coerced to nil for type Float - is coerced to nil for type Symbol - is coerced to nil for type Time - structures types - is coerced to nil for type Array - is coerced to nil for type Set - special types - is coerced to nil for type [JSON] - is coerced to nil for type JSON - variant-member-type collections - is coerced to nil for type [Integer, String] - is coerced to nil for type [Integer, String, [Integer, String]] - Array - Array of Integers - Set of type implementing parse - Array of a custom type - Array of Bools - Array of type implementing parse + json + Grape::API::Boolean + BigDecimal nil values special types respects the nil value @@ -4130,11 +3425,10 @@ variant-member-type collections respects the nil value respects the nil value - structures types + primitive types respects the nil value respects the nil value respects the nil value - primitive types respects the nil value respects the nil value respects the nil value @@ -4144,184 +3438,183 @@ respects the nil value respects the nil value respects the nil value + structures types respects the nil value respects the nil value respects the nil value - json - BigDecimal - Grape::API::Boolean + Array + Array of a custom type + Array of Bools + Array of type implementing parse + Array of Integers + Set of type implementing parse Set Set of Integers Set of Bools + empty string + structures types + is coerced to nil for type Set + is coerced to nil for type Array + special types + is coerced to nil for type [JSON] + is coerced to nil for type JSON + variant-member-type collections + is coerced to nil for type [Integer, String] + is coerced to nil for type [Integer, String, [Integer, String]] + primitive types + is coerced to nil for type FalseClass + is not coerced to nil for type String + is coerced to nil for type BigDecimal + is coerced to nil for type DateTime + is coerced to nil for type Time + is coerced to nil for type Integer + is coerced to nil for type Symbol + is coerced to nil for type TrueClass + is coerced to nil for type Grape::API::Boolean + is coerced to nil for type Numeric + is coerced to nil for type Float + is coerced to nil for type Date + using coerce_with + parses parameters with Array type + parses parameters even if type is valid + parses parameters with Array[Integer] type + parses parameters with Array[Array[String]] type and coerce_with + must be supplied with :type or :coerce + accepts any callable + uses parse where available + parses parameters with Array[String] type + Array type and coerce_with should + not coerce missing field + coerce array as array + coerce nil value to array + Integer type and coerce_with should + coerce integer as integer + coerce nil value to integer + not coerce missing field + Integer type and coerce_with potentially returning nil + accepts value that coerces to nil + coerces to Integer + returns invalid value if coercion returns a wrong type + i18n + gives an english fallback error when default locale message is blank + i18n error on malformed input + with a custom validation message + errors on malformed input + on custom coercion rules + respects :coerce_with + performs no additional coercion + still validates type multiple types - fails when no coercion is possible - may not be supplied together with a single type coerces to first possible type + may not be supplied together with a single type + fails when no coercion is possible custom coercion rules respects :coerce_with - performs no additional coercion still validates type + performs no additional coercion for primitive collections + allows singular form declaration allows multiple collection types allows collections with multiple types - allows singular form declaration when params is Hashie::Mash for primitive collections - allows collections with multiple types allows multiple collection types allows singular form declaration - first-class JSON - accepts Array[JSON] shorthand - doesn't make sense using coerce_with - parses objects, hashes, and arrays - works when declared optional - using coerce_with - must be supplied with :type or :coerce - parses parameters with Array type - parses parameters with Array[Integer] type - accepts any callable - parses parameters with Array[Array[String]] type and coerce_with - parses parameters even if type is valid - parses parameters with Array[String] type - uses parse where available - Integer type and coerce_with should - coerce nil value to integer - not coerce missing field - coerce integer as integer - Array type and coerce_with should - coerce nil value to array - not coerce missing field - coerce array as array - Integer type and coerce_with potentially returning nil - returns invalid value if coercion returns a wrong type - coerces to Integer - accepts value that coerces to nil - -Grape::Extensions::Hash::ParamBuilder - in an api - symbolizes params keys - symbolizes the params - #params - is Hash - in an endpoint - #params - is of type Hash - -Grape::Validations::Validators::ValuesValidator - raises IncompatibleOptionValues when except contains a value that is not a kind of the type - allows a valid default value - does not allow an invalid value for a parameter using lambda - does not validate updated values without proc - allows values to be a kind of the coerced type not just an instance of it - raises IncompatibleOptionValues on an invalid default value from proc - does not allow invalid value using lambda - validates against values in an endless range - allows a valid value for a parameter - allows a valid default value -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows a default value with except -Error 'comparison of String with 0 failed' raised while validating attribute 'number' - does not allow non-numeric string value for int value using lambda - does not allow an invalid value for a parameter - allows a proc for values - rejects all values if values is an empty array - allows value using lambda - raises IncompatibleOptionValues on an invalid default value - allows a blank value when the allow_blank option is true - does not allow an invalid value for a parameter using an endless range - validates default value from proc against values in a proc - allows values to be a kind of the coerced type in an array - validates against values in a proc - validates default value from proc - raises IncompatibleOptionValues when values contains a value that is not a kind of the type - allows numeric string for int value using lambda - raises IncompatibleOptionValues when type is incompatible with values array - validates against an empty array in a proc -Error 'undefined method `>' for nil:NilClass - - requires :number, type: Integer, values: ->(v) { v > 0 } - ^' raised while validating attribute 'number' - does not allow nil for int value using lambda - boolean values - rejects a value which is not in the list - allows a value from the list - nil value for a parameter - allows for a required param in child scope - does not allow for root params scope - accepts for an optional param with a list of values - with a range of values - rejects an array of values if any of them are outside the range - rejects a single value outside the range - allows a single value inside of the range - allows an array of values inside of the range - exclude with a standard custom validation message -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - does not allow an invalid value for a parameter - with a custom validation message - does not allow an invalid value for a parameter - does not allow an invalid value for a parameter using lambda - validates against values in a proc - allows a valid value for a parameter - exclusive excepts with lambda and coercion -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects values that matches except -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows any other value outside excepts - with mixed values and excepts -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows value, but not in except -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects except -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects outside except and outside value - with a custom exclude validation message -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - does not allow an invalid value for a parameter - custom validation using proc -DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects an invalid value among valid ones -DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects a single invalid value -DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - accepts a single valid value -DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - uses supplied message -DEPRECATION WARNING: The values validator proc option is deprecated. The lambda expression can now be assigned directly to values. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - accepts multiple valid values - when arity is > 1 -Error 'wrong number of arguments (given 1, expected 2)' raised while validating attribute 'input_one' -Error 'wrong number of arguments (given 1, expected 2)' raised while validating attribute 'input_two' - returns an error status code - when proc has an arity of 1 - rejects an invalid value - accepts a valid value - exclusive excepts with lambda -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows any other value outside excepts when type is included -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects values that matches except -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows any other value outside excepts - with a custom exclude validation message -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - does not allow an invalid value for a parameter - exclusive excepts -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows any other value outside excepts when type is included -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows any other value outside excepts -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects values that matches except -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - rejects an array of values if any of them matches except - with a lambda values - only evaluates values dynamically with each request - chooses default + allows collections with multiple types + converter + does not build a coercer multiple times Grape::Endpoint post 405 +Rack::Sendfile + when streaming non file content + not contains Sendfile headers + when calling sendfile + contains Sendfile headers + +Grape::Endpoint + get + responds without ext + put + responds + +Grape + .config + is expected to eq {:param_builder=>Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder} + +Grape::Middleware::Base + is able to access the response + has the app as an accessor + calls through to the app + callbacks + calls #after + calls #before + header overwrite + overwrites header by after headers + callbacks on error + calls #after + options + persists options passed at initialization + defaults + overrides default options when provided + persists the default options + after callback with errors + does not overwrite the application response + with patched warnings + does show a warning + #context + allows access to response context + #response + when Array + returns the memoized Rack::Response instance + body + status + header + when Rack::Response + header + returns the memoized Rack::Response instance + body + status + header + is able to set a header + after callback + overwrites application response + +Grape::DSL::Parameters + #includes + is alias to #use + #use_scope + is alias to #use + #use + raises error when non-existent named param is called + calls processes associated with named params + #mutually_exclusive + adds an mutally exclusive parameter validation + #all_or_none_of + adds an all or none of parameter validation + #with + creates a scope with group attributes + #exactly_one_of + adds an exactly of one parameter validation + #at_least_one_of + adds an at least one of parameter validation + #params + inherits params from parent + when params argument is a hash + returns value for @element key + when params argument is not a array or a hash + returns empty hash + when params argument is an array of hashes + returns values of each hash for @element key + #group + is alias to #requires + #requires + adds a required parameter + #optional + adds an optional parameter + Grape::Validations::Validators::SameAsValidator /custom-message is not the same @@ -4329,566 +3622,674 @@ is the same is expected to eq "" / - is the same - is expected to eq "" is not the same is expected to eq "password_confirmation is not the same as password" + is the same + is expected to eq "" -Grape::Validations::Types::SetCoercer - #call - a set of primitives - coerces elements to the set - a set of sets - coerces elements in the nested set - a set of sets of arrays - coerces elements in the nested set +Grape::Exceptions::InvalidResponse + #message + contains the problem in the message -MultiJson - uses multi_json (PENDING: Temporarily skipped with xit) +Grape::Validations::Validators::RegexpValidator + accepts nil + accepts valid input + custom validation message + accepts valid input + accepts nil + regexp with array + refuses nil items + refuses empty items + refuses inapppopriate items + accepts nil instead of array + accepts valid items + with invalid input + refuses empty + refuses inapppopriate + invalid input + refuses empty + refuses inapppopriate + regexp with array + accepts valid items + refuses inapppopriate items + refuses empty items + accepts nil instead of array + refuses nil items + nested regexp with array + refuses inapppopriate -Grape::Endpoint - get - routes to namespace and path params with dots, with merged requirements - routes to a namespace param with dots - routes to a path with multiple params with dots - routes to namespace and path params with dots, with overridden requirements +Grape::Exceptions::ValidationErrors + message + is not repeated + is expected to eq 1 + is expected to include "FooBar is invalid" + initialize + assigns headers through base class + api + can return structured json with separate fields + #full_messages + with errors + returns an array with each errors full message + when attributes is an array of symbols + returns an array with an error full message -Grape::Request - #params - by default returns stringified parameter keys - with grape.routing_args - cuts version and route_info - when build_params_with: Grape::Extensions::Hash::ParamBuilder is specified - returns symbolized params - #headers - with non-HTTP_* stuff in env - does not include them - with symbolic header names - converts them to string - with http headers in env - cuts HTTP_ prefix and capitalizes header name words - when the build_params_with is set to Hashie - when the API does not include a specific param builder - is expected to be a kind of Hash - when the API includes a specific param builder - is expected to be a kind of Hashie::Mash +Grape +/build/reproducible-path/ruby-grape-2.0.0/lib/grape/eager_load.rb:20: warning: possibly useless use of :: in void context + compile! + eager_load! + +Grape::Middleware::Versioner::Path + sets the API version based on the first path + does not cut the version out of the path + provides a nil version if no path is given + with specified versions as ["v1", "v2"] + allows versions that have been specified + throws an error if a non-allowed version is specified + with specified versions as [:v1, "v2"] + throws an error if a non-allowed version is specified + allows versions that have been specified + with specified versions as ["v1", :v2] + throws an error if a non-allowed version is specified + allows versions that have been specified + with a pattern + sets the version if it matches + ignores the version if it fails to match + with specified versions as [:v1, :v2] + allows versions that have been specified + throws an error if a non-allowed version is specified + with mount path + recognizes potential version + with prefix, but requested version is not matched + recognizes potential version + +Grape::DSL::Callbacks + .before + adds a block to "before" + .after_validation + adds a block to "after_validation" + .after + adds a block to "after" + .before_validation + adds a block to "before_validation" + +Grape::API::Instance + boolean constant + sets Boolean as a type + Params endpoint type + params type is a boolean Grape::API - an endpoint without documentation - still declares params internally - does not document parameters for the endpoint an endpoint with documentation allows documentation with a hash documents parameters + an endpoint without documentation + still declares params internally + does not document parameters for the endpoint -Grape::Endpoint - #file - get -DEPRECATION WARNING: Use sendfile or stream to send files. (called from block (4 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/dsl/inside_route_spec.rb:250) - fowards call to sendfile - emits a warning that this method is deprecated - set - as object (backward compatibility) - emits a warning that this method is deprecated -DEPRECATION WARNING: Use stream to use a Stream object. (called from block (5 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/dsl/inside_route_spec.rb:235) - forwards the call to stream - as file path -DEPRECATION WARNING: Use sendfile or stream to send files. (called from block (5 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/dsl/inside_route_spec.rb:219) - forwards the call to sendfile - emits a warning that this method is deprecated - #present - dummy - presents dummy object - with - entity - instance - presents dummy object - multiple entities - instance - presents both dummy objects - non mergeable entity - instance - fails - #error! - throws :error - thrown - sets status - default_error_status - sets status to default_error_status - #redirect - permanent - sets location header - sets status to 301 - default - sets location header - sets status to 302 - #content_type - returns default - set - returns value - #cookies - returns an instance of Cookies - #route - returns route_info - #body - returns default - false - sets status to 204 - set - returns value - #version - returns env[api.version] - defaults to nil - #status - defaults to 200 on GET - accepts unknown Integer status codes - defaults to 200 on GET - defaults to 200 on DELETE with a body present - defaults to 204 on DELETE - defaults to 200 on GET - raises error if status is not a integer or symbol - raises error if unknow symbol is passed - defaults to 201 on POST - returns status set - accepts symbol for status - #sendfile - returns default - set - as file path - does not change the Content-Length header - does not change the Cache-Control header - does not change the Transfer-Encoding header - returns value wrapped in StreamResponse - sends no deprecation warnings - as object - raises an error that only a file path is supported - #stream - returns default - set - as a stream object - sets Cache-Control header to no-cache - returns value wrapped in StreamResponse - sets Content-Length header to nil - sets Transfer-Encoding header to nil - emits no deprecation warnings - as a non-stream object - raises an error that the object must implement :each - as a file path - sets Cache-Control header to no-cache - returns file body wrapped in StreamResponse - sets Transfer-Encoding header to nil - sets Content-Length header to nil - does not change Cache-Control header - emits no deprecation warnings - #return_no_content - sets the status code and body - #declared - is not available by default - -Grape::Exceptions::UnknownValidator - #message - contains the problem in the message - -Grape::Exceptions::InvalidResponse +Grape::Exceptions::InvalidFormatter #message contains the problem in the message -Rack::Sendfile - when calling sendfile - contains Sendfile headers - when streaming non file content - not contains Sendfile headers - -Grape::API - with a global namespace function - works +Grape::Validations::Validators::AtLeastOneOfValidator + #validate! + when all restricted params are present + does not return a validation error + mixed with other params + does not return a validation error + when restricted params are nested inside array + when none of them are present + returns a validation error with full names of the params + when at least one of them is present + does not return a validation error + when restricted params are deeply nested + when at least one of them is present + does not return a validation error + when none of them are present + returns a validation error with full names of the params + when none of the restricted params is selected + returns a validation error + when custom message is specified + returns a validation error + when restricted params are nested inside hash + when none of them are present + returns a validation error with full names of the params + when at least one of them is present + does not return a validation error + when exactly one of the restricted params is selected + does not return a validation error + when a subset of restricted params are present + does not return a validation error -Grape::DSL::Headers - when headers are set - #header - delete - deletes a header key-value pair - set - returns value - get - returns all set headers - returns a specifc value - when no headers are set - #header - returns nil +Grape::Extensions::Hash::ParamBuilder + in an api + symbolizes the params + symbolizes params keys + #params + is Hash + in an endpoint + #params + is of type Hash Grape::Endpoint - #declared; with multiple route_param - return only :artist_id without :id - return :compositor_id for mounter in route_param - return only :id without :artist_id - return :filter and :id parameters in declared for second enpoint inside route_param - #declared; from a nested mounted endpoint - can access parent attributes - #declared - builds nested params when given array - stringifies if that option is passed - shows nil for nested params if include_missing is true - does not include missing attributes if that option is passed - has as many keys as there are declared params - shows nil for multiple allowed types if include_missing is true - does not include missing attributes when there are nested hashes - includes missing attributes with defaults when there are nested hashes - does not include renamed missing attributes if that option is passed - has a optional param with default value all the time - filters out any additional params that are given - includes attributes with value that evaluates to nil - includes attributes with value that evaluates to false - does not work in a before filter - builds nested params - builds arrays correctly - when the param is missing and include_missing=false - sets nested objects to be nil - when params are not built with default class - returns an object that corresponds with the params class - hash -W, [2025-12-18T11:57:16.409751 #125357] WARN -- : You are setting a key that conflicts with a built-in method Hashie::Mash#first defined in Enumerable. This can cause unexpected behavior when accessing the key as a property. You can still access the key via the #[] method. -W, [2025-12-18T11:57:16.410372 #125357] WARN -- : You are setting a key that conflicts with a built-in method Hashie::Mash#first defined in Enumerable. This can cause unexpected behavior when accessing the key as a property. You can still access the key via the #[] method. - returns an object that corresponds with the params class - hashie mash - returns an object that corresponds with the params class - hash with indifferent access - when the param is missing and include_missing=true - sets objects with type=Hash to be a hash - includes all declared children when type=Hash - sets objects with type=Array to be an array - sets objects with type=Set to be a set - #declared; call from child namespace - is expected to eq 200 - with include_parent_namespaces: true - returns declared parameters from every parent namespace - with include_parent_namespaces: false - returns declared parameters only from current namespace - without declaration - returns all requested parameters - #declared; mixed nesting - can access parent route_param - parameter renaming - with a deeply nested parameter structure - maps no parameters when none are given - does not modify the request params - maps the renamed parameter correctly - generates the correct parameter names for documentation - with a renamed root parameter - maps the renamed parameter correctly (original name) - ignores the renamed parameter (as name) - generates the correct parameter names for documentation - validates the renamed parameter correctly (original name) - with a renamed hash with nested parameters - ignores the renamed parameter (as name) - validates the renamed parameter correctly (original name) - maps the renamed parameter correctly (original name) - generates the correct parameter names for documentation - with a renamed hash with nested renamed parameter - ignores the renamed parameter (as name, 3) - maps the renamed parameter correctly (original name) - generates the correct parameter names for documentation - validates the renamed parameter correctly (original name) - ignores the renamed parameter (as name, 2) - ignores the renamed parameter (as name, 1) - -Grape::Exceptions::Validation - fails when params are missing - when message is a symbol - stores message_key - when message is a String - does not store the message_key - -Grape::Validations::Validators::PresenceValidator - with a required non-empty string - valid when set - requires when missing - requires when empty - with reused parameter documentation once required and once optional - works with optional - works with required - with triply nested required parameters - validates triple nested parameters - with a required regexp parameter supplied in the POST body - validates id - with a custom type - does not validate their type when it is missing - with required parameters and no type - validates name, company - with multiple parameters per requires - validates for all defined params - with a custom validation message - requires when empty - requires when missing - valid when set - with nested parameters - validates nested parameters - without validation - does not validate for any params - -Grape::Middleware::Auth::Base - authenticates if given valid creds - throws a 401 is wrong auth is given - -Grape::Path - #mount_path - is nil when no mount path setting exists - is nil when the mount path is nil - splits the mount path - #uses_path_versioning? - is true when the version option is path - is false when the version option is header - is false when the version setting is nil - #namespace? - is false when the namespace is the root path - is false when the namespace is nil - is true otherwise - is false when the namespace starts with whitespace - #path - uses the raw path after the namespace - uses the namespace after the mount path and root prefix - root_prefix - is not included when it is nil - is included after the mount path - mount_path - is included when it is not nil - is not included when it is nil - #path? - is false when the path starts with whitespace - is false when the path is nil - is false when the path is the root path - is true otherwise - #root_prefix - splits the mount path - is nil when the mount path is nil - is nil when no root prefix setting exists - #suffix - when using a specific format - accepts specified format - when path versioning is not used - includes a '/' otherwise - does not include a '/' when the path has a namespace - does not include a '/' when the path has a path - when path versioning is used - includes a '/' - #path_with_suffix - combines the path and suffix - when using a specific format - might have a suffix with specified format - #initialize - remebers the settings - remembers the path - remembers the namespace - -Grape::Exceptions::MissingOption - #message - contains the problem in the message + when route modifies param value + param default should not change -Grape::Middleware::Auth::Strategies - Basic Auth - throws a 401 if no auth is given - authenticates if given valid creds - throws a 401 is wrong auth is given +Grape::API::Helpers + defines parameters Grape::Validations require_validator - when found - is expected to equal Grape::Validations::Validators::PresenceValidator when not found raises an error + when found + is expected to equal Grape::Validations::Validators::PresenceValidator params - with block and empty args - works - custom validation - when using requires with a custom validator - validates when param is not present - validates when param is present - nested namespaces - the nested namespace inherits the custom validator - peer namespaces does not have the validator - when nested, specifying a route should clear out the validations for deeper nested params - namespaces nested in peers should also not have the validator - the parent namespace uses the validator - when using optional with a custom validator - validates when param is present - validates with custom validator when param present and incorrect type - skips validation when parameter isn't present - when using options on param - validates param with custom validator with options + required with an Array block + errors when param not present + errors when param is not an Array + doesn't throw a missing param when param is present + adds to declared parameters + doesn't throw a missing param when param is present but empty + optional + doesn't validate when param not present + adds to declared parameters + validates when params is present + validation within arrays + safely handles empty arrays and blank parameters + handle errors for all array elements + can handle new scopes within child elements + errors when a parameter is not present + errors when a parameter is not present in array within array + errors when param is not an Array + required with a Hash block + doesn't throw a missing param when param is present + errors when param is not a Hash + errors when nested param not present + errors when param not present + adds to declared parameters optional with an Array block doesn't throw a missing param when the group isn't present - errors when param is present but isn't an Array - errors when group is present, but required param is not doesn't throw a missing param when both group and param are given + errors when group is present, but required param is not adds to declared parameters - group params with nested params which has a type - errors when group param is invalid - in a group - does not falsely think the param is there if it is provided outside the block - errors when more than one from the set is present - errors when no parameter from the set is present - works when only one from the set is present - group - adds to declared parameters - errors when param not present - doesn't throw a missing param when param is present + errors when param is present but isn't an Array + requires with nested params + validates correctly in deep nested params + hash with a required param with validation + errors when param is not a Hash + works when all params match validation within arrays with JSON + can handle new scopes within child elements errors when a parameter is not present safely handles empty arrays and blank parameters - can handle new scopes within child elements - with block and keyword argument - works - requires :none using Grape::Entity documentation - adds entity documentation to declared params - errors when required_field is not present - works when required_field is present optional using Grape::Entity documentation - works when field_a and field_b are not present - works when field_b is present adds entity documentation to declared params + works when field_b is present works when field_a is present + works when field_a and field_b are not present + requires :all or :none but except a non-existent field using Grape::Entity documentation + requires :none + adds only the entity documentation to declared params, nothing more + requires :all + adds only the entity documentation to declared params, nothing more + required + adds to declared parameters + errors when param not present + doesn't throw a missing param when param is present + works when required field is present but nil custom validator for a Hash - which is required - doesn't throw an error if the validation passes - errors if the validation fails which is optional + errors if the validation fails doesn't throw an error if the validation passes + which is required errors if the validation fails - requires with nested params - validates correctly in deep nested params - hash with a required param with validation - errors when param is not a Hash - works when all params match - required with a Hash block - doesn't throw a missing param when param is present - adds to declared parameters + doesn't throw an error if the validation passes + required with an Array and a Hash block + does not output index [0] for Hash types + with block and empty args + works + group errors when param not present - errors when param is not a Hash - errors when nested param not present + adds to declared parameters + doesn't throw a missing param when param is present + with block and keyword argument + works + in a group + errors when more than one from the set is present + works when only one from the set is present + errors when no parameter from the set is present + does not falsely think the param is there if it is provided outside the block all or none optional params with a custom validation message works when all params are present - works when none are present errors when any one is present - required - works when required field is present but nil - doesn't throw a missing param when param is present + works when none are present + nested optional Array blocks + does no internal validations if the outer group is blank + handles validation within arrays adds to declared parameters - errors when param not present - requires :all using Grape::Entity documentation - adds entity documentation to declared params - works when required_field is present - errors when required_field is not present - named - can be included in usual params - by #use with multiple params - by #use - with block - overrides default value for order - returns defaults - overrides default value for order_by - fails with invalid value - can be defined - in helper module which kind of Grape::DSL::Helpers::BaseHelper - in helpers - required with an Array and a Hash block - does not output index [0] for Hash types - multiple validation errors - throws the validation errors + at_least_one_of + exactly_one_of + all_or_none_of + handles deep nesting + does internal validations if the outer group is present + Issue occurs whenever: +* param structure with at least three levels +* 1st level item is a required Array that has >1 entry with an optional item present and >1 entry with an optional item missing +* 2nd level is an optional Array or Hash +* 3rd level is a required item (can be any type) +* additional levels do not effect the issue from occuring + correctly indexes invalida data + simplest example using Array -> Hash -> String + example based off actual real world use case + simplest example using Array -> Array -> Hash -> String + multiple levels of optional and requires settings + with invalid data + with valid data exactly one of params - errors when none are present - errors when two or more are present succeeds when one is present + errors when two or more are present + errors when none are present with a custom validation message errors when none are present - succeeds when one is present errors when two or more are present + succeeds when one is present nested params errors when none are present errors when two or more are present succeeds when one is present - with block param - group defaults to Array type - optional defaults to Array type - requires defaults to Array type - optional - validates when params is present - doesn't validate when param not present - adds to declared parameters - requires :all or :none but except a non-existent field using Grape::Entity documentation - requires :none - adds only the entity documentation to declared params, nothing more - requires :all - adds only the entity documentation to declared params, nothing more mutually exclusive optional params errors when two or more are present with custom validation message errors when two or more are present + in a group + works when only one from the set is present + errors when more than one from the set is present mutually exclusive params inside Hash group invalidates if request param is invalid type more than one set of mutually exclusive params errors for all sets with a custom validation message errors for all sets - in a group - works when only one from the set is present - errors when more than one from the set is present + custom validation + when using optional with a custom validator + validates when param is present + validates with custom validator when param present and incorrect type + skips validation when parameter isn't present + when using options on param + validates param with custom validator with options + when using requires with a custom validator + validates when param is present + validates when param is not present + nested namespaces + peer namespaces does not have the validator + the parent namespace uses the validator + namespaces nested in peers should also not have the validator + when nested, specifying a route should clear out the validations for deeper nested params + the nested namespace inherits the custom validator at least one of params does not error when two are present - errors when none are present does not error when one is present + errors when none are present with a custom validation message - errors when none are present does not error when two are present + errors when none are present does not error when one is present nested params - errors when none are present - does not error when two are present does not error when one is present - validation within arrays - safely handles empty arrays and blank parameters - handle errors for all array elements - errors when a parameter is not present in array within array - can handle new scopes within child elements - errors when param is not an Array - errors when a parameter is not present - required with an Array block - doesn't throw a missing param when param is present but empty - adds to declared parameters - doesn't throw a missing param when param is present - errors when param not present - errors when param is not an Array - nested optional Array blocks - does internal validations if the outer group is present - at_least_one_of - adds to declared parameters - handles deep nesting - exactly_one_of - all_or_none_of - does no internal validations if the outer group is blank - handles validation within arrays - Issue occurs whenever: -* param structure with at least three levels -* 1st level item is a required Array that has >1 entry with an optional item present and >1 entry with an optional item missing -* 2nd level is an optional Array or Hash -* 3rd level is a required item (can be any type) -* additional levels do not effect the issue from occuring - simplest example using Array -> Hash -> String - example based off actual real world use case - correctly indexes invalida data - simplest example using Array -> Array -> Hash -> String - multiple levels of optional and requires settings - with invalid data - with valid data + does not error when two are present + errors when none are present + requires :all using Grape::Entity documentation + adds entity documentation to declared params + works when required_field is present + errors when required_field is not present + with block param + group defaults to Array type + optional defaults to Array type + requires defaults to Array type + multiple validation errors + throws the validation errors + group params with nested params which has a type + errors when group param is invalid + named + can be defined + in helpers + in helper module which kind of Grape::DSL::Helpers::BaseHelper + with block + returns defaults + overrides default value for order_by + overrides default value for order + fails with invalid value + can be included in usual params + by #use + by #use with multiple params + requires :none using Grape::Entity documentation + works when required_field is present + errors when required_field is not present + adds entity documentation to declared params + +Grape::Exceptions::MissingOption + #message + contains the problem in the message + +Grape::Extensions::Hashie::Mash::ParamBuilder + in an endpoint + #params + is of type Hashie::Mash + in an api + is indifferent to key or symbol access + #params + is Hashie::Mash + in a nested namespace api + is Hashie::Mash Grape::API - doesn't work for format different than specified - works for specified format - works for unspecified format + .recognize_path + fetches endpoint by given path + returns nil if given path does not match with registered routes -A named API - can access the name of the API +Grape::Presenters::Presenter + represent + represent object + present + instance + presents dummy hash + multiple presenter + instance + presents both dummy presenter + +Grape::Validations::Validators::DefaultValidator + set default values for optional params and allow to use required fields in the same time + set default values for missing params in the request + sets default values for grouped arrays + sets lambda based defaults at the time of call + set default values for optional params + set default value for optional param + does not allows faulty optional arrays + allows optional arrays with optional params + lets you leave required values nested inside an optional blank + allows optional arrays to be omitted + optional group with defaults + optional hash without default value includes optional param with default value + does not fail even if invalid params is passed to default validator + returns nil for optional hash if param is not provided + optional array without default value includes optional param with default value + returns nil for optional array if param is not provided + optional array with default value includes optional param with default value + sets default value for optional array if param is not provided + optional hash with default value includes optional param with default value + sets default value for optional hash if param is not provided + sets default value from parent defaults for inner param if parent param is not provided + sets own default value for inner param if parent param is provided + array with default values and given conditions + applies the default values only if the conditions are met + optional with nil as value + primitive types + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + variant-member-type collections + respects the default value + respects the default value + respects the default value + respects the default value + structures types + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + special types + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + respects the default value + +Grape::Exceptions::Base + #compose_message + when I18n does not enforce available locales + when the fallback locale is not available + returns the translated message + when the fallback locale is available + returns the translated message + when I18n enforces available locales + when the fallback locale is not available + returns the translation string + when the fallback locale is available + returns the translated message + #to_s + is expected to eq "a_message" + #message + is expected to eq "a_message" + +Grape::Middleware::Error + + is possible to return the backtrace and the original exception in xml format + + responds to custom Grape exceptions appropriately + + does not trap regular error! codes + + is possible to return the backtrace and the original exception in txt format + with rescue_options :backtrace and :exception set to true + is possible to return the backtrace and the original exception in json format + + is possible to return errors in json format + + is possible to return hash errors in xml format + + is possible to return errors in xml format + + is possible to return errors in jsonapi format + Non-StandardError exception with a provided rescue handler + default error response + rescues the exception using the default handler + custom error response + rescues the exception using the provided handler + + is possible to specify a different default status code + with defaults + does not trap errors by default + + is possible to return hash errors in json format + + is possible to specify a custom formatter + + is possible to return hash errors in jsonapi format + with rescue_all + StandardError exception + defaults to a 500 status + sets the message appropriately + Non-StandardError exception + does not trap errors other than StandardError + +Grape::API::Helpers + overriding subclass + with lack of expected params + returns missing error + given expected params + overrides helpers from a superclass + non overriding subclass + given expected params + inherits helpers from a superclass + with lack of expected params + returns missing error + example subclass + given expected params + inherits helpers from a superclass + with lack of expected params + returns missing error + +Grape::Validations::SingleAttributeIterator + #each + when params is an array + yields every single attribute from the list for each of the array elements + when missing optional value + does not yield skipped values + empty values + marks params with empty values + when params is a hash + yields params and every single attribute from the list + +Grape::Exceptions::InvalidAcceptHeader + API with cascade=true and without a rescue handler + that received a request with correct vendor and version + behaves like a valid request + does return the expected result + does return with status 200 + that receives + an invalid vendor in the request + behaves like a cascaded request + does not find a matching route + an invalid version in the request + behaves like a cascaded request + does not find a matching route + API with cascade=false, http_codes but without a rescue handler + that received a request with correct vendor and version + behaves like a valid request + does return the expected result + does return with status 200 + that receives + an invalid vendor in the request + behaves like a not-cascaded request + does not accept the request + does not include the X-Cascade=pass header + an invalid version in the request + behaves like a not-cascaded request + does not accept the request + does not include the X-Cascade=pass header + API with cascade=true and rescue_from :all handler + that receives + an invalid version in the request + behaves like a cascaded request + does not find a matching route + an invalid vendor in the request + behaves like a cascaded request + does not find a matching route + that received a request with correct vendor and version + behaves like a valid request + does return with status 200 + does return the expected result + API with cascade=false and with rescue_from :all handler and http_codes + that received a request with correct vendor and version + behaves like a valid request + does return the expected result + does return with status 200 + that receives + an invalid vendor in the request + behaves like a rescued request + does not include the X-Cascade=pass header + does show rescue handler processing + API with cascade=false and rescue_from :all handler + that receives + an invalid vendor in the request + behaves like a rescued request + does show rescue handler processing + does not include the X-Cascade=pass header + that received a request with correct vendor and version + behaves like a valid request + does return the expected result + does return with status 200 + API with cascade=true and with rescue_from :all handler and http_codes + that receives + an invalid vendor in the request + behaves like a cascaded request + does not find a matching route + an invalid version in the request + behaves like a cascaded request + does not find a matching route + that received a request with correct vendor and version + behaves like a valid request + does return with status 200 + does return the expected result + API with cascade=true, http_codes but without a rescue handler + that receives + an invalid vendor in the request + behaves like a cascaded request + does not find a matching route + an invalid version in the request + behaves like a cascaded request + does not find a matching route + that received a request with correct vendor and version + behaves like a valid request + does return with status 200 + does return the expected result + API with cascade=false and without a rescue handler + that received a request with correct vendor and version + behaves like a valid request + does return with status 200 + does return the expected result + that receives + an invalid version in the request + behaves like a not-cascaded request + does not accept the request + does not include the X-Cascade=pass header + an invalid vendor in the request + behaves like a not-cascaded request + does not include the X-Cascade=pass header + does not accept the request + +Grape::DSL::Helpers + .helpers + uses many provided modules + adds a module with the given block + uses provided modules + with an external file + sets Boolean as a Grape::API::Boolean + in child classes + is available + +Grape::Validations::ParamsScope::AttributesDoc + #document + documentation is disabled + does not document attributes + documentation is enabled + documents attributes + false as a default value + is still documented + behaves like an optional doc attribute + does not mention it + nil as a default value + is still documented + behaves like an optional doc attribute + does not mention it + behaves like an optional doc attribute + does not mention it + behaves like an optional doc attribute + does not mention it + the description key instead of desc + adds the given description + behaves like an optional doc attribute + does not mention it + #extract_details + tells when attributes are required + does not clean up doc attrs mandatory for validators + cleans up doc attrs needed for documentation only Grape::Validations::MultipleAttributesIterator #each @@ -4899,381 +4300,1016 @@ when params is empty optional placeholder does not yield it -Grape::Validations::Types::PrimitiveCoercer +Grape::Middleware::Formatter + input + ignores application/x-www-form-urlencoded + parses the body from an xml PATCH and copies values into rack.request.from_hash + rewinds IO + ignores multipart/related + ignores application/x-www-form-urlencoded + parses the chunked body from PATCH and copies values into rack.request.from_hash + ignores multipart/mixed + ignores multipart/form-data + ignores multipart/related + ignores multipart/form-data + ignores multipart/form-data + ignores application/x-www-form-urlencoded + parses the body from an xml DELETE and copies values into rack.request.from_hash + rewinds IO + parses the body from an xml PUT and copies values into rack.request.from_hash + rewinds IO + ignores multipart/related + parses the chunked body from PUT and copies values into rack.request.from_hash + ignores multipart/mixed + ignores multipart/mixed + ignores multipart/mixed + rewinds IO + ignores multipart/related + parses the chunked body from POST and copies values into rack.request.from_hash + ignores application/x-www-form-urlencoded + parses the chunked body from DELETE and copies values into rack.request.from_hash + ignores multipart/form-data + parses the body from an xml POST and copies values into rack.request.from_hash + application/json; charset=utf-8 + parses the body from PUT and copies values into rack.request.form_hash + application/json; charset=utf-8 + parses the body from DELETE and copies values into rack.request.form_hash + when body is not nil or empty + when Content-Type is not supported + returns a 415 HTTP error status + when Content-Type is supported + parses the body from POST and copies values into rack.request.form_hash + when body is nil + does not read and parse the body + application/json + parses the body from DELETE and copies values into rack.request.form_hash + when body is not nil or empty + when Content-Type is not supported + returns a 415 HTTP error status + when Content-Type is supported + parses the body from DELETE and copies values into rack.request.form_hash + when body is empty + does not read and parse the body + when body is nil + does not read and parse the body + when body is empty + does not read and parse the body + application/json; charset=utf-8 + parses the body from POST and copies values into rack.request.form_hash + when body is empty + does not read and parse the body + application/json + parses the body from POST and copies values into rack.request.form_hash + when body is nil + does not read and parse the body + when body is not nil or empty + when Content-Type is supported + parses the body from PATCH and copies values into rack.request.form_hash + when Content-Type is not supported + returns a 415 HTTP error status + application/json + parses the body from PATCH and copies values into rack.request.form_hash + when body is not nil or empty + when Content-Type is not supported + returns a 415 HTTP error status + when Content-Type is supported + parses the body from PUT and copies values into rack.request.form_hash + application/json; charset=utf-8 + parses the body from PATCH and copies values into rack.request.form_hash + when body is empty + does not read and parse the body + when body is nil + does not read and parse the body + application/json + parses the body from PUT and copies values into rack.request.form_hash + serialization + looks at the bodies for possibly serializable data + default format + calls #to_json since default format is json + jsonapi + calls #to_json if the content type is jsonapi + xml + calls #to_xml if the content type is xml + format + uses custom json formatter + uses custom formatter + default + uses default json formatter + send file + returns a file response + detection + uses the json extension if one is provided + uses the file extension format if provided before headers + uses the xml extension if one is provided + uses the requested format if provided in headers + uses the format parameter if one is provided + uses the default format if none is provided + content-type + is set for txt + is set for xml + is set to closest generic for custom vendored/versioned without registered type + is set for vendored with registered type + is set for custom + is set for json + error handling + rescues formatter-specific exceptions +caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError + does not rescue other exceptions + accept header detection + ignores invalid quality rankings + handles quality rankings that have a default 1.0 value + uses quality rankings to determine formats + ensures that a quality of 0 is less preferred than any other content type + detects from the Accept header + parses headers with other attributes + parses headers with symbols as hash keys + handles quality rankings mixed with nothing + parses headers with vendor and api version + with custom vendored content types + uses the custom type + custom parser raises exception and rescue options are enabled for backtrace and original_exception + adds the backtrace and original_exception to the error output + inheritable formatters + returns response by invalid formatter + no content responses + does not modify a 151 response + does not modify a 177 response + does not modify a 197 response + does not modify a 146 response + does not modify a 176 response + does not modify a 173 response + does not modify a 122 response + does not modify a 159 response + does not modify a 112 response + does not modify a 187 response + does not modify a 175 response + does not modify a 174 response + does not modify a 204 response + does not modify a 121 response + does not modify a 114 response + does not modify a 170 response + does not modify a 157 response + does not modify a 107 response + does not modify a 110 response + does not modify a 168 response + does not modify a 156 response + does not modify a 165 response + does not modify a 171 response + does not modify a 161 response + does not modify a 134 response + does not modify a 199 response + does not modify a 113 response + does not modify a 138 response + does not modify a 186 response + does not modify a 167 response + does not modify a 150 response + does not modify a 128 response + does not modify a 166 response + does not modify a 188 response + does not modify a 163 response + does not modify a 179 response + does not modify a 100 response + does not modify a 129 response + does not modify a 133 response + does not modify a 190 response + does not modify a 152 response + does not modify a 141 response + does not modify a 195 response + does not modify a 178 response + does not modify a 124 response + does not modify a 169 response + does not modify a 189 response + does not modify a 185 response + does not modify a 123 response + does not modify a 101 response + does not modify a 118 response + does not modify a 182 response + does not modify a 184 response + does not modify a 181 response + does not modify a 180 response + does not modify a 183 response + does not modify a 149 response + does not modify a 139 response + does not modify a 142 response + does not modify a 145 response + does not modify a 120 response + does not modify a 153 response + does not modify a 131 response + does not modify a 135 response + does not modify a 158 response + does not modify a 198 response + does not modify a 130 response + does not modify a 191 response + does not modify a 106 response + does not modify a 125 response + does not modify a 109 response + does not modify a 103 response + does not modify a 155 response + does not modify a 147 response + does not modify a 111 response + does not modify a 192 response + does not modify a 144 response + does not modify a 104 response + does not modify a 115 response + does not modify a 193 response + does not modify a 126 response + does not modify a 148 response + does not modify a 102 response + does not modify a 127 response + does not modify a 154 response + does not modify a 136 response + does not modify a 164 response + does not modify a 119 response + does not modify a 105 response + does not modify a 304 response + does not modify a 132 response + does not modify a 108 response + does not modify a 140 response + does not modify a 196 response + does not modify a 117 response + does not modify a 194 response + does not modify a 116 response + does not modify a 160 response + does not modify a 143 response + does not modify a 172 response + does not modify a 137 response + does not modify a 162 response + +Grape::API + doesn't work for format different than specified + works for unspecified format + works for specified format + +Grape::Middleware::Versioner::Header + succeeds if :strict is set to false and given an invalid header + succeeds if :strict is not set + succeeds if :strict is set to false + with missing vendor option + fails + api.format + is set + is nil if not provided + when version is set to v1 + is nil if not provided + is set + when version is set to v1 + is nil if not provided + is set + api.version + is set if format provided + fails with 406 Not Acceptable if version is invalid + is set + when multiple versions are specified + succeeds with v1 + succeeds with v2 + fails with another version + api.vendor + is set + fails with 406 Not Acceptable if vendor is invalid + is set if format provided + when version is set + is set if format provided + is set + fails with 406 Not Acceptable if vendor is invalid + api.type and api.subtype + sets preferred type and subtype + sets preferred type + sets type and subtype to first choice of content type if no preference given + when there are multiple versions with complex vendor specified with rescue_from :all + with header versioned endpoints and a rescue_all block defined + responds correctly to a v1 request + responds correctly to a v2 request + when :strict is set + fails with 406 Not Acceptable if header is not set + succeeds if proper header is set + fails with 406 Not Acceptable if header is empty + when :strict and cascade: false + succeeds if proper header is set + fails with 406 Not Acceptable if header is empty + fails with 406 Not Acceptable if header is application/xml + fails with 406 Not Acceptable if header is not set + fails with 406 Not Acceptable if header contains a single invalid accept + +Grape::Validations::Types::ArrayCoercer #call - the strict mode - Boolean - returns an error when the given value is not Boolean - returns a value as it is when the given value is Boolean - BigDecimal - returns an error when the given value is not BigDecimal - returns a value as it is when the given value is BigDecimal - Numeric - accepts a non-nil value - coerces an empty string to nil - Integer - accepts non-nil value - coerces an empty string to nil - Time - coerces an empty string to nil - Float - coerces an empty string to nil - a type unknown in Dry-types - raises error on init - String - coerces to String - does not coerce an empty string to nil - Boolean - coerces '1' to true - coerces 'true' to true - coerces 'false' to false - coerces 'false' to false - returns an error when the given value cannot be coerced - coerces '0' to false - coerces an empty string to nil - coerces 'true' to true - Symbol - coerces an empty string to nil - BigDecimal - coerces an empty string to nil - coerces to BigDecimal - DateTime - coerces an empty string to nil + an array of primitives + coerces elements in the array + an array of arrays + coerces elements in the nested array + an array of sets + coerces elements in the nested set -Grape::Extensions::Hashie::Mash::ParamBuilder - in an endpoint - #params - is of type Hashie::Mash - in an api - is indifferent to key or symbol access - in a nested namespace api - is Hashie::Mash - #params - is Hashie::Mash +Grape::DSL::Settings + #unset_route_setting + delegates to unset + #unset_global_setting + delegates to unset + #namespace_stackable + delegates to get_or_set + stacks values from surrounding namespace + #global_setting + delegates to get_or_set + #namespace_inheritable + inherits values from surrounding namespace + delegates to get_or_set + complex scenario + plays well + #unset_api_class_setting + delegates to unset + #api_class_setting + delegates to get_or_set + #get_or_set + sets a values + returns a value when nil is new value is provided + #unset_namespace_setting + delegates to unset + #unset_namespace_stackable + delegates to unset + #namespace_setting + delegates to get_or_set + resets values after leaving nested namespaces + sets a value until the end of a namespace + #unset + deletes a key from settings + #route_setting + sets a value until the next route + delegates to get_or_set + #within_namespace + returns the last result + calls start and end for a namespace + #unset_namespace_inheritable + delegates to unset -Grape::DSL::Logger - .logger - sets a logger - returns a logger +Grape::Middleware::Versioner + recognizes :header + recognizes :accept_version_header + recognizes :param + recognizes :path -Grape::Middleware::Error - has a default message - sets the status code based on the rack util status code symbol - defaults to a 500 status - sets the status code appropriately - sets the error message appropriately - with http code - adds the status code if wanted - presents an error message +Grape::Util::ReverseStackableValues + #keys + returns merged keys with parent + returns all keys + #[] + returns an array of values + returns parent value when no value is set + parent values are not changed + combines parent and actual values (actual first) + #to_hash + returns a Hash representation + #[]= + can handle array values + pushes further values + sets a value + #clone + copies all values + complex (i.e. not primitive) data types (ex. middleware, please see bug #930) + copies values; does not duplicate them + #delete + does not delete parent values + deletes a key -Grape::DSL::RequestResponse - .format - sets a new format - .parser - sets a parser for a content type - .default_error_formatter - sets a new error formatter - .default_format - returns the format without paramter - sets the default format - .rescue_from - :all - abort if :with option value is not Symbol, String or Proc - sets rescue all to true - sets a rescue handler declared through :with option - sets given proc as rescue handler - sets given block as rescue handler - abort if both :with option and block are passed - :grape_exceptions - sets a rescue handler declared through :with option - sets given block as rescue handler - sets given proc as rescue handler - sets rescue all to true - list of exceptions is passed - rescues only base handlers if rescue_subclasses: false option is passed - sets given block as rescue handler for each key in hash - sets a rescue handler declared through :with option for each key in hash - sets given proc as rescue handler for each key in hash - sets hash of exceptions as rescue handlers - .error_formatter - understands syntactic sugar - sets a error_formatter - .content_types - returns all content types - .content_type - sets a content type for a format - .represent - sets a presenter for a class - .formatter - sets the formatter for a content type - .default_error_status - sets a default error status +Grape::API::Helpers + defines parameters -MultiXml - uses multi_xml +Grape::Middleware::Versioner::AcceptVersionHeader + succeeds if :strict is set to false + succeeds if :strict is not set + api.version + is set + is set if format provided + fails with 406 Not Acceptable if version is not supported + when :strict and cascade: false + fails with 406 Not Acceptable if header is not set + succeeds if proper header is set + fails with 406 Not Acceptable if header is empty + when :strict is set + fails with 406 Not Acceptable if header is not set + succeeds if proper header is set + fails with 406 Not Acceptable if header is empty + +Grape::Util::InheritableValues + #delete + deletes a key + does not delete parent values + #[] + returns parent value when no value is set + overwrites parent value with the current one + returns a value + parent values are not changed + #[]= + sets a value + #to_hash + returns a Hash representation + #clone + complex (i.e. not primitive) data types (ex. entity classes, please see bug #891) + copies values; does not duplicate them Rack correctly populates params from a Tempfile when the app is mounted finds the app on the namespace -Grape::Validations::ParamsScope - returns a sensible error message within a nested context - includes level 2 nested parameters outside the given within #declared(params) - raises an error if the dependent parameter was never specified - includes the nested parameter within #declared(params) - includes deeply nested parameters within #declared(params) - when validations are dependent on a parameter with specific value - (case 1) - skips validation when base param does not have a specified value - includes the parameter within #declared(params) - applies the validation when base param has the specific value - skips validation when base param is missing - (case 9) - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - includes the parameter within #declared(params) - (case 0) - includes the parameter within #declared(params) - skips validation when base param is missing - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - (case 14) - includes the parameter within #declared(params) - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - (case 7) - includes the parameter within #declared(params) - skips validation when base param is missing - applies the validation when base param has the specific value - skips validation when base param does not have a specified value - (case 10) - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - includes the parameter within #declared(params) - (case 5) - applies the validation when base param has the specific value - includes the parameter within #declared(params) - skips validation when base param does not have a specified value - skips validation when base param is missing - (case 11) - applies the validation when base param has the specific value - includes the parameter within #declared(params) - skips validation when base param does not have a specified value - (case 4) - skips validation when base param is missing - applies the validation when base param has the specific value - skips validation when base param does not have a specified value - includes the parameter within #declared(params) - (case 12) - includes the parameter within #declared(params) - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - (case 13) - applies the validation when base param has the specific value - skips validation when base param does not have a specified value - includes the parameter within #declared(params) - (case 15) - applies the validation when base param has the specific value - skips validation when base param does not have a specified value - includes the parameter within #declared(params) - (case 3) - includes the parameter within #declared(params) - skips validation when base param is missing - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - (case 6) - includes the parameter within #declared(params) - skips validation when base param is missing - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - (case 8) - includes the parameter within #declared(params) - applies the validation when base param has the specific value - skips validation when base param does not have a specified value - (case 2) - skips validation when base param does not have a specified value - applies the validation when base param has the specific value - includes the parameter within #declared(params) - skips validation when base param is missing - with range values - when left range endpoint isn't #kind_of? the type - raises exception - when right range endpoint isn't #kind_of? the type - raises exception - when both range endpoints are #kind_of? the type - rejects values outside the range - accepts values in the range - when the default is an array - and is a subset of allowed values - does not raise an exception - and is the entire range of allowed values - does not raise an exception - when validations are dependent on a parameter within an array param - passes none Hash params - when validations are dependent on a parameter - applies the validations only if the parameter is present - applies the validations of multiple parameters - includes the parameter within #declared(params) - does not raise an error if when using nested given - allows renaming of dependent parameters - raises an error if the dependent parameter was never specified - returns a sensible error message within a nested context - includes the nested parameter within #declared(params) - includes level 2 nested parameters outside the given within #declared(params) - does not raise an error if the dependent parameter is a Hash - applies only the appropriate validation - allows nested dependent parameters - does not validate nested requires when given is false - detect unmet nested dependency - allows renaming of dependent on parameter - raises an error if the dependent parameter is the renamed one - does not raise if the dependent parameter is not the renamed one - when the dependent parameter is not present #declared(params) - lateral parameter within lateral hash parameter - evaluate_given_true - evaluate_given_false - lateral parameter - evaluate_given_true - evaluate_given_false - lateral hash parameter - evaluate_given_true - evaluate_given_false - nested given parameter within an array param - evaluate_given_false - evaluate_given_true - nested given parameter within a nested given parameter within an array param - evaluate_given_false - evaluate_given_true - lateral parameter within an array param - evaluate_given_false - evaluate_given_true - nested given parameter - evaluate_given_true - evaluate_given_false - when using custom types - coerces the parameter via the type's parse method - array without coerce type explicitly given - sets the type based on first element - raises exception when range values have different endpoint types - fails to call API without Array type - raises exception when values are of different type - when validations are dependent on a parameter within an array param within #declared(params).to_json - applies the constraint within each value - when params have group attributes - with validations - when data is invalid - applies group validations for every parameter - returns a validation error - when parameter has the same validator as a group - returns a successful response - prioritizes parameter validation over group validation - with several group attributes - when data is invalid - returns a validation error - responds with HTTP error - when correct data is provided - returns a successful response - with nested groups - when correct data is provided - returns a successful response - when data is invalid - returns a validation error - responds with HTTP error - with types - when invalid date provided - returns a validation error - responds with HTTP error - when created_at receives a valid date - returns a successful response - returns a date - parameters in group - allows Array as type - errors with an unsupported type - allows Hash as type - handles missing optional Array type - errors when no type is provided - with exactly_one_of validation for optional parameters within an Hash param - when invalid data is provided - returns a failure response - when correct data is provided - returns a successful response - failing fast - when fail_fast is not defined - does not stop validation - when fail_fast is defined it stops the validation - of other params - for a single param - default value in given block - when dependency does not meet - does not set default value for dependent parameter - when dependency meets - sets default value for dependent parameter - param renaming - is expected to eq "foo is empty" - renaming can be defined before default - is expected to eq "{\"baz\":{\"qux\":\"any\"}}" - renaming can be defined after default - is expected to eq "-there we go" - is expected to eq 200 - is expected to eq "any-any2" - coercing values validation with proc -DEPRECATION WARNING: The values validator except option is deprecated. Use the except validator instead. (called from new at /build/reproducible-path/ruby-grape-2.0.0/lib/grape/validations/validator_factory.rb:7) - allows the proc to pass validation without checking in except - allows the proc to pass validation without checking in value - allows the proc to pass validation without checking - -Grape::Exceptions::InvalidFormatter - #message - contains the problem in the message - Grape::Middleware::Versioner::Param - cuts (only) the version out of the params sets the API version based on the default param (apiver) provides a nil version if no version is given - when there are multiple versions without a custom param - responds correctly to a v2 request - responds correctly to a v1 request + cuts (only) the version out of the params when no version is set returns a 200 (matches the first version found) - with specified versions - allows versions that have been specified - throws an error if a non-allowed version is specified + when there are multiple versions without a custom param + responds correctly to a v1 request + responds correctly to a v2 request with specified parameter name does not set the API version based on the default param sets the API version based on the custom parameter name when there are multiple versions with a custom param - responds correctly to a v2 request responds correctly to a v1 request + responds correctly to a v2 request + with specified versions + allows versions that have been specified + throws an error if a non-allowed version is specified -Grape::DSL::Validations - .params - returns a ParamsScope - evaluates block - .reset_validations! - resets params - does not reset documentation description - resets validations - resets declared params +Grape::Parser + .builtin_parsers + includes json and xml parsers by default + returns an instance of Hash + .parsers + includes built-in parsers + returns an instance of Hash + with :parsers option + includes passed :parsers values + with added parser by using `register` keyword + includes added parser + .parser_for + returns parser correctly + calls .parsers + when parser is available + returns registered parser if available + when parser is an instance of Symbol + returns an instance of Method + returns object which can be called + when parser does not exist + returns nil -Grape::Validations::Validators::AllOrNoneOfValidator +Grape::Exceptions::ValidationErrors + api without a rescue handler + with content_type xml + can recover from failed body parsing + and with content_type json + can recover from failed body parsing + with content_type text + can recover from failed body parsing + and with no specific content_type + can recover from failed body parsing + api with rescue_from :all handler + with content_type json + can recover from failed body parsing + with content_type xml + can recover from failed body parsing + with no specific content_type + can recover from failed body parsing + with content_type text + can recover from failed body parsing + api with rescue_from :grape_exceptions handler with block + with content_type xml + returns body parsing error message + with content_type json + returns body parsing error message + api with rescue_from :grape_exceptions handler + with content_type xml + returns body parsing error message + with content_type json + returns body parsing error message + +Grape::Validations::Validators::Base + #inherited + when validator is anonymous + does not register the validator + when validator's underscored name ends with _validator + registers the custom validator with short name not ending with validator + when validator's underscored name does not end with _validator + registers the custom validator with a short name + +Grape::Validations::Validators::MutualExclusionValidator #validate! - when mutually exclusive params are nested inside array - returns a validation error with full names of the params - when all restricted params are present + when no mutually exclusive params are present does not return a validation error - mixed with other params + when mutually exclusive params are nested inside optional hash + when params are passed + returns a validation error with full names of the params + when params are empty does not return a validation error - when no restricted params are present - does not return a validation error - when custom message is specified + when all mutually exclusive params are present returns a validation error - when a subset of restricted params are present + mixed with other params + returns a validation error + when a subset of mutually exclusive params are present returns a validation error + when mutually exclusive params are nested inside required hash + returns a validation error with full names of the params when mutually exclusive params are deeply nested returns a validation error with full names of the params - when restricted params are nested inside required hash + when mutually exclusive params are nested inside array returns a validation error with full names of the params + when custom message is specified + returns a validation error + +Grape::Middleware::Stack + #build + returns a rack builder instance + when @others are present + applies the middleware specs stored in @others + #concat + calls +merge_with+ with the :use specs + adds non :use specs to @others + #use + pushes a middleware class with arguments onto the stack + pushes a middleware class onto the stack + pushes a middleware class with block arguments onto the stack + #insert + inserts a middleware class at the integer index + #insert_after + raises an error on an invalid index + inserts a middleware after another middleware class + inserts a middleware after an anonymous class given by its superclass + #insert_before + inserts a middleware before an anonymous class given by its superclass + raises an error on an invalid index + inserts a middleware before another middleware class + #merge_with + applies a collection of operations and middlewares + middleware spec with proc declaration exists + properly forwards spec arguments + +Grape::Middleware::Auth::DSL + .http_digest + when realm is a hash + sets auth parameters + when realm is not hash + sets auth parameters + .http_basic + sets auth parameters + .auth + can be called multiple times + sets auth parameters + +Grape::DSL::RequestResponse + .formatter + sets the formatter for a content type + .default_error_formatter + sets a new error formatter + .default_error_status + sets a default error status + .error_formatter + understands syntactic sugar + sets a error_formatter + .represent + sets a presenter for a class + .rescue_from + :grape_exceptions + sets rescue all to true + sets given proc as rescue handler + sets a rescue handler declared through :with option + sets given block as rescue handler + list of exceptions is passed + sets given block as rescue handler for each key in hash + sets hash of exceptions as rescue handlers + sets a rescue handler declared through :with option for each key in hash + rescues only base handlers if rescue_subclasses: false option is passed + sets given proc as rescue handler for each key in hash + :all + sets given block as rescue handler + sets rescue all to true + abort if both :with option and block are passed + sets a rescue handler declared through :with option + sets given proc as rescue handler + abort if :with option value is not Symbol, String or Proc + .content_type + sets a content type for a format + .format + sets a new format + .default_format + sets the default format + returns the format without paramter + .content_types + returns all content types + .parser + sets a parser for a content type + +Grape::DSL::Logger + .logger + sets a logger + returns a logger + +Grape::Validations::Types + ::build_coercer + caches the result of the build_coercer method + has internal cache variables + ::special? + provides special handling for [JSON] + provides special handling for File + provides special handling for Rack::Multipart::UploadedFile + provides special handling for JSON + ::structure? + recognizes Array as a structure + recognizes Hash as a structure + recognizes Set as a structure + ::primitive? + recognizes Symbol as a primitive + identifies unknown types + recognizes Date as a primitive + recognizes Grape::API::Boolean as a primitive + recognizes Time as a primitive + recognizes Numeric as a primitive + recognizes DateTime as a primitive + recognizes Integer as a primitive + recognizes BigDecimal as a primitive + recognizes String as a primitive + recognizes Float as a primitive + ::custom? + returns false if the type's #parse method takes other than one argument + returns true if the type responds to :parse with one argument + returns false if the type does not respond to :parse + special types + when Array[JSON] + is expected to eq Grape::Validations::Types::JsonArray + when Rack::Multipart::UploadedFile + is expected to eq Grape::Validations::Types::File + when File + is expected to eq Grape::Validations::Types::File + when JSON + is expected to eq Grape::Validations::Types::Json + +Grape::DSL::Routing + .route_param + calls #namespace with given params + does not modify options parameter + nests requirements option under param name + .routes + returns value received from #prepare_routes + when #routes was already called once + does not call prepare_routes again + .namespace + calls #joined_space_path on Namespace + creates a new namespace with given name and options + .get + delegates to .route + .route + generates correct endpoint options + marks end of the route + resets validations + does not duplicate identical endpoints + defines a new endpoint + .mount + mounts on a nested path + mounts multiple routes at once + .resources + is alias to #namespace + .version + sets a version for route + .put + delegates to .route + .do_not_route_head! + sets do not route head option + .group + is alias to #namespace + .segment + is alias to #namespace + .options + delegates to .route + .resource + is alias to #namespace + .patch + delegates to .route + .do_not_route_options! + sets do not route options option + .delete + delegates to .route + .post + delegates to .route + .versions + returns last defined version + .head + delegates to .route + .scope + create a scope without affecting the URL + .prefix + sets a prefix for route + +Grape::Endpoint + get + no format + json format + invalid format + +Grape::Exceptions::MissingMimeType + #message + contains the resolution in the message + contains the problem in the message + +Grape::Endpoint + put + responds + get + responds + +Grape::Exceptions::InvalidVersionerOption + #message + contains the problem in the message + +Grape::Exceptions::UnknownOptions + #message + contains the problem in the message + +Grape::Endpoint + sets itself in the env upon call + does not persist params between calls + allows explicit return calls + resets all instance variables (except block) between calls + #cookies + sets browser cookies and does not set response cookies + sets and update browser cookies + is callable from within a block + deletes cookie + deletes cookies with path + validation errors + returns the errors, and passes headers + #header + is callable from within a block + .before_each + is able to stack helper + is settable via reference + is able to override a helper + is settable via block + filters + allows adding to response with present + when terminating the response with error! + allows prior and parent filters of same type to run + breaks normal call chain + before filters + runs the before filter if set + after filters + overrides the response body if it sets it + does not override the response body with its return + anchoring + delete 204 + allows for the anchoring option with a delete method + anchors paths by default for the delete method + responds to /example/and/some/more for the non-anchored delete method + delete 200, with a return value (no explicit body) + responds to /example delete method + delete 204, with empty array has return value (no explicit body) + responds to /example delete method + all other + anchors paths by default for the OPTIONS method + allows for the anchoring option with a PATCH method + anchors paths by default for the PATCH method + allows for the anchoring option with a GET method + responds to /example/and/some/more for the non-anchored OPTIONS method + anchors paths by default for the GET method + anchors paths by default for the POST method + allows for the anchoring option with a PUT method + allows for the anchoring option with a HEAD method + anchors paths by default for the PUT method + responds to /example/and/some/more for the non-anchored POST method + allows for the anchoring option with a POST method + responds to /example/and/some/more for the non-anchored PUT method + responds to /example/and/some/more for the non-anchored GET method + anchors paths by default for the HEAD method + responds to /example/and/some/more for the non-anchored HEAD method + allows for the anchoring option with a OPTIONS method + responds to /example/and/some/more for the non-anchored PATCH method + delete 200, with response body + responds to /example/and/some/more for the non-anchored delete method + delete 204, with nil has return value (no explicit body) + responds to /example delete method + #initialize + takes a settings stack, options, and a block + #method_missing + when referencing an undefined local variable + raises NoMethodError but stripping the internals of the Grape::Endpoint class and including the API route + when performing an undefined method of an instance inside the API + raises NoMethodError but stripping the internals of the Object class + #headers + includes headers passed as symbols + includes additional request headers + includes request headers + request + includes version v1 + is set to the url requested + includes version v1 + includes prefix + #status + is set as default to 200 for get + is callable from within a block + is set as default to 201 for post + binary +DEPRECATION WARNING: Use stream to use a Stream object. (called from block (4 levels) in at /build/reproducible-path/ruby-grape-2.0.0/spec/grape/endpoint_spec.rb:1001) + suports stream objects in response + #error! + accepts a frozen object + does not merges additional headers with headers set after call + accepts a message + can specifiy headers + accepts a code + accepts an object and render it in format + merges additional headers with headers set before call + sets the status code for the endpoint + #redirect + support permanent redirect + allows for an optional redirect body override + has status code 303 if it is not get request and it is http 1.1 + redirects to a url with status 302 + version headers + result in a 406 response if they are invalid + result in a 406 response if they cannot be parsed by rack-accept + #params + default class + is a ActiveSupport::HashWithIndifferentAccess + sets a value to params + params + .generate_api_method + returns a Proc + raises NameError if the method name is already in use + raises ArgumentError if a block is not given + #params + does not accept text/plain in JSON format if application/json is specified as content type + parses from path segments + is available to the caller + responds with a 415 for an unsupported content-type + deeply converts nested params + with special requirements + parses many params with provided regexps + parses email param with provided requirements for params + namespace requirements + overrides outer namespace's requirements + parse email param with provided requirements for params + precedence + route string params have higher precedence than URL params + route string params have higher precedence than body params + sets a value to params + params + from body parameters + returns a 400 if given an invalid multipart body + does not convert empty JSON bodies to params + converts XML bodies to params + does not include parameters not defined by the body + converts JSON bodies to params + converts XML bodies to params + content type with params + responses with given content type in headers + does not response with 406 for same type without params + when the limit on multipart files is exceeded + returns a 413 if given too many multipart files + instrumentation + notifies AS::N + +Grape::Validations::Types::PrimitiveCoercer + #call + Float + coerces an empty string to nil + String + coerces to String + does not coerce an empty string to nil + Symbol + coerces an empty string to nil + Time + coerces an empty string to nil + the strict mode + Boolean + returns a value as it is when the given value is Boolean + returns an error when the given value is not Boolean + BigDecimal + returns a value as it is when the given value is BigDecimal + returns an error when the given value is not BigDecimal + BigDecimal + coerces to BigDecimal + coerces an empty string to nil + Numeric + coerces an empty string to nil + accepts a non-nil value + Integer + accepts non-nil value + coerces an empty string to nil + a type unknown in Dry-types + raises error on init + Boolean + coerces 'false' to false + coerces 'false' to false + coerces '1' to true + returns an error when the given value cannot be coerced + coerces 'true' to true + coerces '0' to false + coerces an empty string to nil + coerces 'true' to true + DateTime + coerces an empty string to nil + +Grape::Http::Headers + is expected to eq "Allow" + is expected to eq "X-Cascade" + is expected to eq "Transfer-Encoding" + is expected to eq "Location" + +Grape::Exceptions::Validation + fails when params are missing + when message is a String + does not store the message_key + when message is a symbol + stores message_key + +Grape::API::Helpers + patch + public + default + private + default + default + public + private + +Grape::Request + #params + by default returns stringified parameter keys + when build_params_with: Grape::Extensions::Hash::ParamBuilder is specified + returns symbolized params + with grape.routing_args + cuts version and route_info + #headers + with non-HTTP_* stuff in env + does not include them + with symbolic header names + converts them to string + with http headers in env + cuts HTTP_ prefix and capitalizes header name words + when the build_params_with is set to Hashie + when the API does not include a specific param builder + is expected to be a kind of Hash + when the API includes a specific param builder + is expected to be a kind of Hashie::Mash + +Grape::Path + #path_with_suffix + combines the path and suffix + when using a specific format + might have a suffix with specified format + #suffix + when path versioning is used + includes a '/' + when using a specific format + accepts specified format + when path versioning is not used + does not include a '/' when the path has a path + does not include a '/' when the path has a namespace + includes a '/' otherwise + #root_prefix + is nil when no root prefix setting exists + splits the mount path + is nil when the mount path is nil + #path? + is false when the path starts with whitespace + is false when the path is the root path + is true otherwise + is false when the path is nil + #initialize + remebers the settings + remembers the path + remembers the namespace + #mount_path + is nil when the mount path is nil + splits the mount path + is nil when no mount path setting exists + #namespace? + is false when the namespace starts with whitespace + is false when the namespace is nil + is true otherwise + is false when the namespace is the root path + #uses_path_versioning? + is false when the version option is header + is true when the version option is path + is false when the version setting is nil + #path + uses the namespace after the mount path and root prefix + uses the raw path after the namespace + root_prefix + is included after the mount path + is not included when it is nil + mount_path + is not included when it is nil + is included when it is not nil + +Grape::API::Instance + with multiple moutes + does not raise a FrozenError on second instance + responds the correct body at the second instance + responds the correct body at the first instance + does not raise a FrozenError on first instance + when an instance is mounted on the root + can call the instance endpoint + top level setting + does not inherit settings from the superclass (Grape::API::Instance) + when an instance is the root + can call the instance endpoint Pending: (Failures listed here are expected and do not affect your suite's status) @@ -5281,10 +5317,10 @@ # Temporarily skipped with xit # ./spec/integration/multi_json/json_spec.rb:4 -Finished in 6.41 seconds (files took 1.33 seconds to load) +Finished in 10.14 seconds (files took 2.23 seconds to load) 2171 examples, 0 failures, 1 pending -Randomized with seed 4865 +Randomized with seed 1404 ┌──────────────────────────────────────────────────────────────────────────────┐ @@ -5315,12 +5351,14 @@ dpkg-buildpackage: info: binary-only upload (no source included) dpkg-genchanges: info: not including original source code in upload I: copying local configuration +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/B01_cleanup starting +I: user script /srv/workspace/pbuilder/53943/tmp/hooks/B01_cleanup finished I: unmounting dev/ptmx filesystem I: unmounting dev/pts filesystem I: unmounting dev/shm filesystem I: unmounting proc filesystem I: unmounting sys filesystem I: cleaning the build env -I: removing directory /srv/workspace/pbuilder/119924 and its subdirectories -I: Current time: Thu Dec 18 11:57:21 -12 2025 -I: pbuilder-time-stamp: 1766102241 +I: removing directory /srv/workspace/pbuilder/53943 and its subdirectories +I: Current time: Sat Nov 16 07:35:33 +14 2024 +I: pbuilder-time-stamp: 1731692133