Diff of the two buildlogs: -- --- b1/build.log 2024-12-18 20:56:29.699814381 +0000 +++ b2/build.log 2024-12-18 20:57:38.472692783 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Wed Dec 18 08:55:20 -12 2024 -I: pbuilder-time-stamp: 1734555320 +I: Current time: Wed Jan 21 17:19:30 +14 2026 +I: pbuilder-time-stamp: 1768965570 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/unstable-reproducible-base.tgz] I: copying local configuration @@ -32,54 +32,85 @@ 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/33063/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/29668/tmp/hooks/D01_modify_environment starting +debug: Running on infom08-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 Jan 21 03:19 /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/29668/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/29668/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=11 ' - 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]="37" [3]="1" [4]="release" [5]="i686-pc-linux-gnu") + BASH_VERSION='5.2.37(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=5 ' + 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='e2e28d0810ae41528796dd78dbe8f62c' - 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='33063' - PS1='# ' - PS2='> ' + INVOCATION_ID=e1efe4c657774392bda155d519ac32f8 + 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=29668 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.5ZqjmGJy/pbuilderrc_klLq --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.5ZqjmGJy/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://46.16.76.132: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.5ZqjmGJy/pbuilderrc_fCkA --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.5ZqjmGJy/b2 --logfile b2/build.log ruby-grape_2.0.0-3.dsc' + SUDO_GID=111 + SUDO_UID=104 + SUDO_USER=jenkins + TERM=unknown + TZ=/usr/share/zoneinfo/Etc/GMT-14 + UID=0 + USER=root + _='I: set' I: uname -a - Linux ionos2-i386 6.1.0-28-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.119-1 (2024-11-22) x86_64 GNU/Linux + Linux i-capture-the-hostname 6.11.5+bpo-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.11.5-1~bpo12+1 (2024-11-11) x86_64 GNU/Linux I: ls -l /bin - lrwxrwxrwx 1 root root 7 Nov 22 14:40 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/33063/tmp/hooks/D02_print_environment finished + lrwxrwxrwx 1 root root 7 Nov 22 2024 /bin -> usr/bin +I: user script /srv/workspace/pbuilder/29668/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -331,7 +362,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 1s (48.9 MB/s) +Fetched 47.6 MB in 1s (43.2 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 ... 19952 files and directories currently installed.) @@ -937,8 +968,8 @@ Setting up tzdata (2024b-4) ... Current default time zone: 'Etc/UTC' -Local time is now: Wed Dec 18 20:55:56 UTC 2024. -Universal Time is now: Wed Dec 18 20:55:56 UTC 2024. +Local time is now: Wed Jan 21 03:20:07 UTC 2026. +Universal Time is now: Wed Jan 21 03:20:07 UTC 2026. Run 'dpkg-reconfigure tzdata' if you wish to change it. Setting up autotools-dev (20220109.1) ... @@ -1095,7 +1126,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/29668/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for unstable +I: user script /srv/workspace/pbuilder/29668/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 +1167,7 @@ │ ruby-grape: Installing files and building extensions for ruby3.1 │ └──────────────────────────────────────────────────────────────────────────────┘ -/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20241218-44191-bl97cn/gemspec +/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20260121-4112-blshhu/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 +1187,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/d20241218-44191-bl97cn/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/d20260121-4112-blshhu/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,573 +1370,469 @@ /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 54938 +Randomized with seed 42951 -Grape::Validations::Types::SetCoercer - #call - a set of sets - coerces elements in the nested set - a set of primitives - coerces elements to the set - a set of sets of arrays - coerces elements in the nested set - -Grape::DSL::Routing - .delete - delegates to .route - .group - is alias to #namespace - .route_param - calls #namespace with given params - nests requirements option under param name - does not modify options parameter - .head - delegates to .route - .prefix - sets a prefix for route - .segment - is alias to #namespace - .put - delegates to .route - .resources - is alias to #namespace - .mount - mounts on a nested path - mounts multiple routes at once - .get - delegates to .route - .patch - delegates to .route - .namespace - creates a new namespace with given name and options - calls #joined_space_path on Namespace - .route - resets validations - does not duplicate identical endpoints - defines a new endpoint - marks end of the route - generates correct endpoint options - .post - delegates to .route - .do_not_route_head! - sets do not route head option - .version - sets a version for route - .scope - create a scope without affecting the URL - .versions - returns last defined version - .options - delegates to .route - .resource - is alias to #namespace - .do_not_route_options! - sets do not route options option - .routes - returns value received from #prepare_routes - when #routes was already called once - does not call prepare_routes again - -MultiJson - uses multi_json (PENDING: Temporarily skipped with xit) - -Grape::Validations::Types::PrimitiveCoercer - #call - Numeric - accepts a non-nil value - 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 - Boolean - coerces '0' to false - coerces 'false' to false - coerces 'false' to false - coerces 'true' to true - coerces '1' to true - returns an error when the given value cannot be coerced - coerces an empty string to nil - coerces 'true' to true - DateTime - coerces an empty string to nil - Symbol - coerces an empty string to nil - BigDecimal - coerces to BigDecimal - coerces an empty string to nil - a type unknown in Dry-types - raises error on init - String - does not coerce an empty string to nil - coerces to String - Float - coerces an empty string to nil - Time - coerces an empty string to nil - Integer - accepts non-nil value - coerces an empty string to nil - -MultiXml - uses multi_xml - -Grape::Http::Headers - is expected to eq "Transfer-Encoding" - is expected to eq "X-Cascade" - is expected to eq "Location" - is expected to eq "Allow" - -Grape::Validations::Validators::RegexpValidator - accepts valid input - accepts nil - nested regexp with array - refuses inapppopriate - invalid input - refuses empty - refuses inapppopriate - regexp with array - refuses nil items - accepts nil instead of array - accepts valid items - refuses empty items - refuses inapppopriate items - custom validation message - accepts nil - accepts valid input - with invalid input - refuses inapppopriate - refuses empty - regexp with array - refuses nil items - refuses empty items - refuses inapppopriate items - accepts valid items - accepts nil instead of array - -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 - nil 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 - behaves like an optional doc attribute - does not mention it - behaves like an optional doc attribute - does not mention it - #extract_details - cleans up doc attrs needed for documentation only - does not clean up doc attrs mandatory for validators - tells when attributes are required - -Grape::Endpoint - get - no format - invalid format - json format - -Grape::Validations::MultipleAttributesIterator - #each - when params is empty optional placeholder - does not yield it - when params is a hash - yields the whole params hash without the list of attrs - when params is an array - yields each element of the array without the list of attrs - -Grape::DSL::Callbacks - .before - adds a block to "before" - .after_validation - adds a block to "after_validation" - .before_validation - adds a block to "before_validation" - .after - adds a block to "after" - -Grape::API::Helpers - can access helpers from a mounted resource - can access helpers from a mounted resource in a nested resource +Grape::Validations::Validators::DefaultValidator + does not allows faulty optional arrays + set default value for optional param + set default values for optional params and allow to use required fields in the same time + allows optional arrays with optional params + lets you leave required values nested inside an optional blank + sets default values for grouped arrays + allows optional arrays to be omitted + set default values for optional params + set default values for missing params in the request + sets lambda based defaults at the time of call + array with default values and given conditions + applies the default values only if the conditions are met + optional group with defaults + optional hash without default value includes optional param with default value + returns nil for optional hash if param is not provided + does not fail even if invalid params is passed to default validator + 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 own default value for inner param if parent param is provided + 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 + optional array with default value includes optional param with default value + sets default value for optional array if param is not provided + 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 + 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 + 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::Endpoint - get - responds without ext - responds with ext - put - responds +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 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 -Grape::Middleware::Error - with defaults - does not trap errors by default - - is possible to return hash errors in jsonapi format - - 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 specify a different default status code - - is possible to return hash errors in json format - 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 return the backtrace and the original exception in txt format - - does not trap regular error! codes - - is possible to return the backtrace and the original exception in xml 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 jsonapi format - - responds to custom Grape exceptions appropriately - with rescue_all - Non-StandardError exception - does not trap errors other than StandardError - StandardError exception - defaults to a 500 status - sets the message appropriately - - is possible to return errors in json format +Grape::Exceptions::UnsupportedGroupType + #message + is expected to include "group type must be Array, Hash, JSON or Array[JSON]" + Grape::Exceptions::UnsupportedGroupTypeError + behaves like deprecated class + raises an ActiveSupport::DeprecationException -Grape::Validations::Validators::AllOrNoneOfValidator +Grape::Validations::Validators::MutualExclusionValidator #validate! - when restricted params are nested inside required hash + when mutually exclusive params are deeply nested returns a validation error with full names of the params + when no mutually exclusive params are present + 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 all mutually exclusive params are present + returns a validation error + mixed with other params + returns a validation error 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 - when no restricted params are present - does not return a validation error - when all restricted 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 empty does not return a validation error - when mutually exclusive params are deeply nested - returns a validation error with full names of the params - when a subset of restricted params are present + when params are passed + returns a validation error with full names of the params + when a subset of mutually exclusive params are present returns a validation error -Grape::DSL::Parameters - #includes - is alias to #use - #use - calls processes associated with named params - raises error when non-existent named param is called - #at_least_one_of - adds an at least one of parameter validation - #all_or_none_of - adds an all or none of parameter validation - #group - is alias to #requires - #use_scope - is alias to #use - #optional - adds an optional parameter - #with - creates a scope with group attributes - #mutually_exclusive - adds an mutally exclusive parameter validation - #params - inherits params from parent - 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 - when params argument is a hash - returns value for @element key - #exactly_one_of - adds an exactly of one parameter validation - #requires - adds a required parameter - -Grape::Validations::Validators::PresenceValidator - with triply nested required parameters - validates triple nested parameters - with reused parameter documentation once required and once optional - works with optional - works with required - without validation - does not validate for any params - with a custom validation message - valid when set - requires when empty - requires when missing - with multiple parameters per requires - validates for all defined params - with nested parameters - validates nested parameters - with required parameters and no type - validates name, company - with a required non-empty string - valid when set - requires when missing - requires when empty - 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 - -Grape::DSL::Settings - #namespace_setting - sets a value until the end of a namespace - delegates to get_or_set - resets values after leaving nested namespaces - #get_or_set - sets a values - returns a value when nil is new value is provided - #api_class_setting - delegates to get_or_set - #namespace_stackable - stacks values from surrounding namespace - delegates to get_or_set - #unset_api_class_setting - delegates to unset - #unset - deletes a key from settings - #route_setting - sets a value until the next route - delegates to get_or_set - #unset_namespace_setting - delegates to unset - #global_setting - delegates to get_or_set - #unset_namespace_stackable - delegates to unset - #namespace_inheritable - inherits values from surrounding namespace - delegates to get_or_set - #within_namespace - returns the last result - calls start and end for a namespace - #unset_global_setting - delegates to unset - #unset_route_setting - delegates to unset - #unset_namespace_inheritable - delegates to unset - complex scenario - plays well - -Grape::Validations::Types::ArrayCoercer - #call - an array of arrays - coerces elements in the nested array - an array of primitives - coerces elements in the array - an array of sets - coerces elements in the nested set - -A named API - can access the name of the API - -Grape::API::Instance - boolean constant - sets Boolean as a type - Params endpoint type - params type is a boolean - -Grape::Util::StackableValues - #to_hash - returns a Hash representation - #[] - combines parent and actual values - parent values are not changed - returns parent value when no value is set - returns an array of 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 - does not delete parent values - deletes a key - #keys - returns merged keys with parent - returns all keys - #[]= - sets a value - can handle array values - pushes further values - -Grape::Validations::Validators::ExceptValuesValidator - raises IncompatibleOptionValues on a default value in exclude - 7: opt_except_default - invalid-type1 - 10: opt_except_type_coerce_default - 3 - 2: req_except_custom_message - valid-type - 9: req_except_type_coerce - invalid-type1 - 11: opt_except_array_type_coerce_default - ["3"] - 10: opt_except_type_coerce_default - 10 - 8: opt_except_lambda_default - invalid-type3 - 2: req_except_custom_message - invalid-type1 - 4: req_except_empty - invalid-type1 - 0: req_except - valid-type - 11: opt_except_array_type_coerce_default - 10 - 6: req_except_lambda_custom_message - invalid-type1 - 2: req_except_custom_message - invalid-type3 - 5: req_except_lambda - invalid-type4 - raises IncompatibleOptionValues when a default array has excluded values - 8: opt_except_lambda_default - invalid-type1 - 12: req_except_range - 11 - 7: opt_except_default - - 3: req_except_no_value - invalid-type1 - 11: opt_except_array_type_coerce_default - [10] - 8: opt_except_lambda_default - valid-type - 11: opt_except_array_type_coerce_default - invalid-type1 - 6: req_except_lambda_custom_message - invalid-type4 - 10: opt_except_type_coerce_default - invalid-type1 - 5: req_except_lambda - valid-type - 12: req_except_range - 13 - 9: req_except_type_coerce - 11 - 6: req_except_lambda_custom_message - valid-type - 5: req_except_lambda - invalid-type1 - 9: req_except_type_coerce - 3 - 7: opt_except_default - valid-type - 9: req_except_type_coerce - 11 - 11: opt_except_array_type_coerce_default - - 1: req_except_hash - valid-type - 0: req_except - invalid-type1 - raises IncompatibleOptionValues when type is incompatible with values array - 10: opt_except_type_coerce_default - - 7: opt_except_default - invalid-type3 - 11: opt_except_array_type_coerce_default - [3] - 10: opt_except_type_coerce_default - 3 - 1: req_except_hash - invalid-type1 - 1: req_except_hash - invalid-type3 - 0: req_except - invalid-type3 - 8: opt_except_lambda_default - - 9: req_except_type_coerce - 3 +StrictHashConfiguration + set nested configs -Grape::Endpoint - post - 405 +Rack + correctly populates params from a Tempfile + when the app is mounted + finds the app on the namespace -Grape::Presenters::Presenter - represent - represent object - present - instance - presents dummy hash - multiple presenter - instance - presents both dummy presenter +Grape::Exceptions::MissingGroupType + #message + is expected to include "group type is required" + Grape::Exceptions::MissingGroupTypeError + behaves like deprecated class + raises an ActiveSupport::DeprecationException -Grape::Path - #initialize - remembers the path - remembers the namespace - remebers the settings - #uses_path_versioning? - is false when the version option is header - is false when the version setting is nil - is true when the version option is path - #mount_path - splits the mount path - is nil when no mount path setting exists - is nil when the mount path is nil - #path? - is true otherwise - is false when the path starts with whitespace - is false when the path is nil - is false when the path is the root 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 not used - includes a '/' otherwise - does not include a '/' when the path has a path - does not include a '/' when the path has a namespace - when path versioning is used - includes a '/' - when using a specific format - accepts specified format - #namespace? - is true otherwise - is false when the namespace is the root path - is false when the namespace starts with whitespace - is false when the namespace 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 included when it is not nil - is not included when it is nil - #root_prefix - is nil when no root prefix setting exists - is nil when the mount path is nil - splits the mount path +Grape::Exceptions::InvalidResponse + #message + contains the problem in the message Grape::Http::Headers - is expected to eq "Allow" is expected to eq "Transfer-Encoding" - is expected to eq "Location" is expected to eq "X-Cascade" + is expected to eq "Allow" + is expected to eq "Location" -Grape::Middleware::Versioner::Param - sets the API version based on the default param (apiver) - provides a nil version if no version is given - cuts (only) the version out of the params - when no version is set - returns a 200 (matches the first version found) - with specified versions - throws an error if a non-allowed version is specified - allows versions that have been specified - 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 v1 request - responds correctly to a v2 request - when there are multiple versions without a custom param - responds correctly to a v2 request - responds correctly to a v1 request +Grape::Middleware::Formatter + error handling + rescues formatter-specific exceptions +caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError + does not rescue other exceptions + format + uses custom json formatter + uses custom formatter + default + uses default json formatter + content-type + is set to closest generic for custom vendored/versioned without registered type + is set for txt + is set for vendored with registered type + is set for custom + is set for xml + is set for json + serialization + looks at the bodies for possibly serializable data + default format + calls #to_json since default format is json + xml + calls #to_xml if the content type is xml + jsonapi + calls #to_json if the content type is jsonapi + send file + returns a file response + input + ignores multipart/related + rewinds IO + ignores multipart/form-data + 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 PUT and copies values into rack.request.from_hash + ignores application/x-www-form-urlencoded + rewinds IO + parses the chunked body from PATCH and copies values into rack.request.from_hash + ignores application/x-www-form-urlencoded + ignores multipart/mixed + parses the chunked body from DELETE and copies values into rack.request.from_hash + ignores multipart/form-data + ignores multipart/mixed + ignores multipart/related + parses the body from an xml POST and copies values into rack.request.from_hash + ignores multipart/form-data + ignores multipart/mixed + ignores application/x-www-form-urlencoded + ignores multipart/form-data + parses the body from an xml DELETE and copies values into rack.request.from_hash + ignores multipart/related + parses the body from an xml PATCH and copies values into rack.request.from_hash + ignores multipart/mixed + ignores multipart/related + rewinds IO + rewinds IO + parses the body from an xml PUT and copies values into rack.request.from_hash + when body is empty + does not read and parse the body + 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 empty + does not read and parse the body + application/json; charset=utf-8 + parses the body from PATCH 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 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 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 PUT and copies values into rack.request.form_hash + when Content-Type is not supported + returns a 415 HTTP error status + 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 nil + does not read and parse the body + 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 + application/json + 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 empty + does not read and parse the body + when body is nil + does not read and parse the body + application/json; charset=utf-8 + parses the body from PUT and copies values into rack.request.form_hash + custom parser raises exception and rescue options are enabled for backtrace and original_exception + adds the backtrace and original_exception to the error output + detection + uses the default format if none is provided + uses the json extension if one is provided + uses the format parameter if one is provided + uses the xml extension if one is provided + uses the requested format if provided in headers + uses the file extension format if provided before headers + no content responses + does not modify a 189 response + does not modify a 109 response + does not modify a 149 response + does not modify a 131 response + does not modify a 172 response + does not modify a 177 response + does not modify a 182 response + does not modify a 179 response + does not modify a 168 response + does not modify a 148 response + does not modify a 117 response + does not modify a 199 response + does not modify a 103 response + does not modify a 198 response + does not modify a 110 response + does not modify a 188 response + does not modify a 186 response + does not modify a 129 response + does not modify a 161 response + does not modify a 100 response + does not modify a 130 response + does not modify a 141 response + does not modify a 156 response + does not modify a 106 response + does not modify a 160 response + does not modify a 187 response + does not modify a 163 response + does not modify a 119 response + does not modify a 125 response + does not modify a 165 response + does not modify a 155 response + does not modify a 167 response + does not modify a 133 response + does not modify a 158 response + does not modify a 123 response + does not modify a 174 response + does not modify a 145 response + does not modify a 136 response + does not modify a 176 response + does not modify a 140 response + does not modify a 139 response + does not modify a 194 response + does not modify a 146 response + does not modify a 178 response + does not modify a 164 response + does not modify a 151 response + does not modify a 128 response + does not modify a 105 response + does not modify a 170 response + does not modify a 114 response + does not modify a 107 response + does not modify a 113 response + does not modify a 134 response + does not modify a 102 response + does not modify a 204 response + does not modify a 144 response + does not modify a 122 response + does not modify a 181 response + does not modify a 147 response + does not modify a 120 response + does not modify a 196 response + does not modify a 157 response + does not modify a 150 response + does not modify a 108 response + does not modify a 183 response + does not modify a 112 response + does not modify a 152 response + does not modify a 116 response + does not modify a 192 response + does not modify a 137 response + does not modify a 101 response + does not modify a 115 response + does not modify a 175 response + does not modify a 185 response + does not modify a 126 response + does not modify a 132 response + does not modify a 169 response + does not modify a 111 response + does not modify a 162 response + does not modify a 184 response + does not modify a 166 response + does not modify a 193 response + does not modify a 138 response + does not modify a 135 response + does not modify a 171 response + does not modify a 143 response + does not modify a 104 response + does not modify a 159 response + does not modify a 118 response + does not modify a 124 response + does not modify a 173 response + does not modify a 153 response + does not modify a 154 response + does not modify a 142 response + does not modify a 190 response + does not modify a 195 response + does not modify a 197 response + does not modify a 304 response + does not modify a 180 response + does not modify a 121 response + does not modify a 127 response + does not modify a 191 response + accept header detection + ensures that a quality of 0 is less preferred than any other content type + handles quality rankings mixed with nothing + parses headers with other attributes + parses headers with symbols as hash keys + ignores invalid quality rankings + detects from the Accept header + handles quality rankings that have a default 1.0 value + parses headers with vendor and api version + uses quality rankings to determine formats + with custom vendored content types + uses the custom type + inheritable formatters + returns response by invalid formatter -Grape::Exceptions::UnknownOptions - #message - contains the problem in the message +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 + +Grape::Exceptions::ValidationErrors + #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 + 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 + +Grape::DSL::RequestResponse + .represent + sets a presenter for a class + .rescue_from + :all + sets given proc as rescue handler + abort if :with option value is not Symbol, String or Proc + sets rescue all to true + sets a rescue handler declared through :with option + abort if both :with option and block are passed + sets given block as rescue handler + list of exceptions 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 + rescues only base handlers if rescue_subclasses: false option is passed + :grape_exceptions + sets given proc as rescue handler + sets rescue all to true + sets given block as rescue handler + sets a rescue handler declared through :with option + .parser + sets a parser for a content type + .default_format + sets the default format + returns the format without paramter + .error_formatter + sets a error_formatter + understands syntactic sugar + .content_types + returns all content types + .default_error_status + sets a default error status + .format + sets a new format + .default_error_formatter + sets a new error formatter + .content_type + sets a content type for a format + .formatter + sets the formatter for a content type Grape::API remounting an API with a defined route - when mounting twice - can access the votes in both places 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 - 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 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 in a helper + will use the dynamic configuration on all routes + when mounting an endpoint conditional on a configuration + mounts the endpoints only when configured to do so + when executing a custom block on mount + mounts the endpoints only when configured to do so + when the configuration is read within the response block + will use the dynamic configuration on all routes + a very complex configuration example + when it should not be mounted + gets a response + when the namespace should be mounted + gets a response + when should be mounted is nil + gets a response on the DescSCope mounts the endpoint with the appropiate tags when using an expression derived from a configuration @@ -1910,311 +1841,257 @@ 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 configuration is read in a helper - 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 - when executing a standard block within a `mounted` block with all dynamic params - mounts the API and obtains the description and headers definition - a very complex configuration example - when the namespace should be mounted - gets a response - when should be mounted is nil - 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 the configuration is read within the response block + when the configuration is read within a namespace will use the dynamic configuration on all routes -Grape::Exceptions::MissingGroupType - #message - is expected to include "group type is required" - Grape::Exceptions::MissingGroupTypeError - behaves like deprecated class - raises an ActiveSupport::DeprecationException +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::DSL::Desc - .desc - can be set with options and a block - can be set with a block - sets a description +Grape::Validations::Validators::CoerceValidator + coerce + error on malformed input + error on malformed input (Array) + i18n + gives an english fallback error when default locale message is blank + i18n error on malformed input + first-class JSON + parses objects, hashes, and arrays + doesn't make sense using coerce_with + accepts Array[JSON] shorthand + works when declared optional + using coerce_with + must be supplied with :type or :coerce + accepts any callable + uses parse where available + parses parameters with Array type + parses parameters with Array[Array[String]] type and coerce_with + parses parameters even if type is valid + parses parameters with Array[Integer] type + parses parameters with Array[String] type + Integer type and coerce_with should + coerce nil value to integer + not coerce missing field + coerce integer as integer + 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 + Array type and coerce_with should + coerce nil value to array + coerce array as array + not coerce missing field + with a custom validation message + errors on malformed input + on custom coercion rules + performs no additional coercion + respects :coerce_with + still validates type + coerces + Nests integers + Integer + BigDecimal + Grape::API::Boolean + String + File + File + Rack::Multipart::UploadedFile + collection + empty string + 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 Date + is coerced to nil for type Time + is coerced to nil for type DateTime + is coerced to nil for type Symbol + is coerced to nil for type BigDecimal + is coerced to nil for type FalseClass + is coerced to nil for type Numeric + is not coerced to nil for type String + is coerced to nil for type TrueClass + is coerced to nil for type Float + is coerced to nil for type Integer + is coerced to nil for type Grape::API::Boolean + structures types + is coerced to nil for type Set + is coerced to nil for type Array + json + BigDecimal + Grape::API::Boolean + a custom type + coerces the given value + returning the InvalidValue instance when invalid + uses a custom message added to the invalid value + nil values + structures 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 + respects the nil value + respects the nil value + respects the nil value + respects the nil value + respects the nil value + respects the nil value + respects the nil value + respects the nil value + respects the nil value + special types + respects the nil value + respects the nil value + respects the nil value + respects the nil value + variant-member-type collections + respects the nil value + respects the nil value + Set + Set of Bools + Set of Integers + Array + Set of type implementing parse + Array of Integers + Array of a custom type + Array of type implementing parse + Array of Bools + multiple types + fails when no coercion is possible + coerces to first possible type + may not be supplied together with a single type + when params is Hashie::Mash + for primitive collections + allows multiple collection types + allows singular form declaration + allows collections with multiple types + custom coercion rules + respects :coerce_with + still validates type + performs no additional coercion + for primitive collections + allows singular form declaration + allows multiple collection types + allows collections with multiple types + converter + does not build a coercer multiple times -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 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 +Grape::Middleware::Versioner::Param + provides a nil version if no version is given + cuts (only) the version out of the params + sets the API version based on the default param (apiver) + when no version is set + returns a 200 (matches the first version found) + when there are multiple versions with a custom param + responds correctly to a v2 request + responds correctly to a v1 request + when there are multiple versions without a custom param + 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 + with specified parameter name + sets the API version based on the custom parameter name + does not set the API version based on the default param -Grape::Endpoint - sets itself in the env upon call - resets all instance variables (except block) between calls - does not persist params between calls - allows explicit return calls - #status - is callable from within a block - is set as default to 200 for get - is set as default to 201 for post - anchoring - delete 204, with empty array 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 - delete 200, with a 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 - all other - responds to /example/and/some/more for the non-anchored PUT method - anchors paths by default for the HEAD method - responds to /example/and/some/more for the non-anchored POST method - anchors paths by default for the PATCH method - responds to /example/and/some/more for the non-anchored OPTIONS method - allows for the anchoring option with a POST method - anchors paths by default for the PUT method - allows for the anchoring option with a GET method - anchors paths by default for the OPTIONS method - anchors paths by default for the GET method - allows for the anchoring option with a OPTIONS method - allows for the anchoring option with a PATCH method - anchors paths by default for the POST method - allows for the anchoring option with a HEAD method - responds to /example/and/some/more for the non-anchored HEAD method - allows for the anchoring option with a PUT method - responds to /example/and/some/more for the non-anchored GET method - responds to /example/and/some/more for the non-anchored PATCH method - delete 204 - anchors paths by default for the delete method - allows for the anchoring option with a delete method - responds to /example/and/some/more for the non-anchored delete method - #cookies - sets and update browser cookies - sets browser cookies and does not set response cookies - deletes cookie - is callable from within a block - deletes cookies with path - .generate_api_method - raises ArgumentError if a block is not given - raises NameError if the method name is already in use - returns a Proc - #initialize - takes a settings stack, options, and a block - #params - default class - is a ActiveSupport::HashWithIndifferentAccess - sets a value to params - params - #error! - can specifiy headers - accepts an object and render it in format - accepts a message - sets the status code for the endpoint - merges additional headers with headers set before call - does not merges additional headers with headers set after call - accepts a frozen object - accepts a code - #redirect - redirects to a url with status 302 - allows for an optional redirect body override - support permanent redirect - has status code 303 if it is not get request and it is http 1.1 - #params - parses from path segments - deeply converts nested params - responds with a 415 for an unsupported content-type - is available to the caller - does not accept text/plain in JSON format if application/json is specified as content type - when the limit on multipart files is exceeded - returns a 413 if given too many multipart files - sets a value to params - params - from body parameters - does not convert empty JSON bodies to params - returns a 400 if given an invalid multipart body - converts JSON bodies to params - converts XML bodies to params - does not include parameters not defined by the body - 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 - precedence - route string params have higher precedence than body params - route string params have higher precedence than URL params - with special requirements - parses many params with provided regexps - parses email param with provided requirements for params - namespace requirements - parse email param with provided requirements for params - overrides outer namespace's requirements - instrumentation - notifies AS::N - 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 - validation errors - returns the errors, and passes headers - #header - is callable from within a block - filters - allows adding to response with present - 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 - after filters - does not override the response body with its return - overrides the response body if it sets it +Grape::API + .recognize_path + returns nil if given path does not match with registered routes + fetches endpoint by given path + +Grape::Request #headers - includes headers passed as symbols - includes request headers - includes additional request headers - .before_each - is settable via reference - is able to stack helper - is able to override a helper - is settable via block - version headers - result in a 406 response if they are invalid - result in a 406 response if they cannot be parsed by rack-accept - #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 - request - includes prefix - includes version v1 - is set to the url requested - includes version v1 + with http headers in env + cuts HTTP_ prefix and capitalizes header name words + with symbolic header names + converts them to string + with non-HTTP_* stuff in env + does not include them + 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 + #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 -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::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::Endpoint - #version - defaults to nil - returns env[api.version] - #return_no_content - sets the status code and body - #status - returns status set - defaults to 204 on DELETE - defaults to 200 on GET - defaults to 200 on GET - raises error if status is not a integer or symbol - accepts unknown Integer status codes - raises error if unknow symbol is passed - defaults to 201 on POST - defaults to 200 on DELETE with a body present - defaults to 200 on GET - accepts symbol for status - #redirect - permanent - sets status to 301 - sets location header - default - sets status to 302 - sets location header - #sendfile - returns default - set - as object - raises an error that only a file path is supported - as file path - returns value wrapped in StreamResponse - does not change the Transfer-Encoding header - sends no deprecation warnings - does not change the Content-Length header - does not change the Cache-Control header - #stream - returns default - set - as a non-stream object - raises an error that the object must implement :each - as a stream object - returns value wrapped in StreamResponse - sets Transfer-Encoding header to nil - emits no deprecation warnings - sets Content-Length header to nil - sets Cache-Control header to no-cache - as a file path - sets Content-Length header to nil - sets Cache-Control header to no-cache - returns file body wrapped in StreamResponse - does not change Cache-Control header - emits no deprecation warnings - sets Transfer-Encoding header to nil - #error! - throws :error - thrown - sets status - default_error_status - sets status to default_error_status - #content_type - returns default - set - returns value - #route - returns route_info - #body - returns default - set - returns value - false - sets status to 204 - #declared - is not available by default - #cookies - returns an instance of Cookies - #present - dummy - presents dummy object - with - entity - instance - presents dummy object - multiple entities - instance - presents both dummy objects - non mergeable entity - instance - fails - #file - set - as file path - emits a warning that this method is deprecated -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 - 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 - 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 +Grape::API::Helpers + can access helpers from a mounted resource + can access helpers from a mounted resource in a nested resource + +Grape::Exceptions::ValidationErrors + api without a rescue handler + and with content_type json + can recover from failed body parsing + with content_type xml + 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 :grape_exceptions handler with block + 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 content_type json + returns body parsing error message + with content_type xml + returns body parsing error message + api with rescue_from :all handler + with no specific content_type + can recover from failed body parsing + with content_type json + can recover from failed body parsing + with content_type xml + can recover from failed body parsing + with content_type text + can recover from failed body parsing + +Grape::DSL::Headers + when headers are set + #header + get + returns all set headers + returns a specifc value + set + returns value + delete + deletes a header key-value pair + when no headers are set + #header + returns nil Grape::Validations::Validators::SameAsValidator / @@ -2228,484 +2105,636 @@ is not the same is expected to eq "password_confirmation not match" +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 triply nested required parameters + validates triple nested parameters + without validation + does not validate for any params + with reused parameter documentation once required and once optional + works with required + works with optional + 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 required regexp parameter supplied in the POST body + validates id + with a custom validation message + requires when missing + valid when set + requires when empty + +Grape::Http::Headers + is expected to eq "Transfer-Encoding" + is expected to eq "Allow" + is expected to eq "X-Cascade" + is expected to eq "Location" + Grape::API - .configure + .logger Grape::API - allows configuring the api - when given a block + returns an instance of Logger class by default Grape::API - calls the block passing the config + does not unnecessarily retain duplicate setup blocks + with a custom logger + exposes its interaface + filters Grape::API - returns self - when not given a block + calls filters in the correct order Grape::API - returns a configuration object - with unsafe HTML format specified + calls only before filters when validation fails Grape::API - escapes the HTML - .http_basic + adds a before filter Grape::API - has access to the current endpoint + calls all filters when validation passes Grape::API - can set instance variables accessible to routes + adds a after filter Grape::API - protects any resources on the same scope + adds a after_validation filter Grape::API - has access to helper methods + adds a before filter to current and child namespaces only + .represent Grape::API - is scopable + adds the association to the :representations setting Grape::API - is callable via .auth as well - .change! + requires a :with option + .default_error_status Grape::API - invalidates any compiled instance - with non-UTF-8 characters in specified format + has a default error status Grape::API - converts the characters + uses the default error status in error! +Grape::API + allows setting default_error_status + do_not_route_options! +Grape::API + does not include OPTIONS in Allow header +Grape::API + does not create an OPTIONS route + .namespace +Grape::API + is callable with nil just to push onto the stack +Grape::API + `.segment` is an alias +Grape::API + `.resource` is an alias +Grape::API + is stackable +Grape::API + cancels itself after the block is over +Grape::API + is retrievable and converted to a path +Grape::API + accepts path segments correctly +Grape::API + comes after the prefix and version +Grape::API + `.group` is an alias +Grape::API + `.resources` is an alias .call it does not add to the app setup Grape::API calls the app + .default_format +Grape::API + returns data in default format +Grape::API + parses data in default format instance_for_rack + when the app was mounted +Grape::API + returns the first mounted instance when the app was not mounted Grape::API returns the base_instance - when the app was mounted + .compile Grape::API - returns the first mounted instance - .route + sets the instance + .formatter + multiple formatters Grape::API - allows for multipart paths + sets another formatter Grape::API - allows and properly constrain a OPTIONS method + sets one formatter + custom formatter Grape::API - allows for multiple paths + uses custom formatter Grape::API - runs before filter exactly once on 405 bad method + uses json + custom formatter class Grape::API - allows and properly constrain a PATCH method + uses json Grape::API - returns a 405 for an unsupported method with an X-Custom-Header + uses custom formatter + catch-all Grape::API - allows for :any as a verb + anchor=true Grape::API - 405 responses includes an Allow header specifying supported methods + anchor=false + desc Grape::API - allows and properly constrain a POST method + merges the parameters of nested namespaces Grape::API - handles empty calls + does not inherit param descriptions in consequent namespaces Grape::API - returns a 201 response code for POST by default + groups nested params and prevents overwriting of params with same name in different groups Grape::API - allows for no path + uses full name of parameters in nested groups Grape::API - runs only the before filter on 405 bad method + describes a method with parameters Grape::API - allows for format without corrupting a param + empty array of routes Grape::API - allows and properly constrain a HEAD method + has params which does not include format and version as named captures Grape::API - allows for catch-all in a namespace + empty array of routes Grape::API - allows for multiple verbs + allows to set the type attribute on :group element Grape::API - runs all filters and body with a custom OPTIONS method + includes details Grape::API - allows and properly constrain a GET method + merges the parameters of the namespace with the parameters of the method Grape::API - allows and properly constrain a DELETE method + parses parameters when no description is given Grape::API - overwrites the default HEAD request + describes methods separately Grape::API - allows for format in namespace with no path +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 - 405 responses includes an Content-Type header + resets desc Grape::API - allows and properly constrain a PUT method - format + does not symbolize params Grape::API - allows .json +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 + format Grape::API - allows .txt - when a resource routes by POST, GET, PATCH, PUT, and DELETE - it adds an OPTIONS route for namespaced endpoints that + sets content type for json Grape::API - returns a 204 + sets content type for xml error Grape::API - has an empty body + does not set Cache-Control Grape::API - has an Allow header - put + does not include extension in id Grape::API - stores input in api.request.input +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 - stores input in api.request.input + sets content type for txt format Grape::API - allows a(n) Array json object in params + sets content type for serializable hash format Grape::API - allows a(n) Float json object in params + sets content type for xml Grape::API - stores input in api.request.input + streams the content of the file with stream Grape::API - stores input in api.request.input + sets content type for binary format Grape::API - allows a(n) FalseClass json object in params + sets content type for error Grape::API - allows a(n) TrueClass json object in params + returns raw data when content type binary Grape::API - allows a(n) NilClass json object in params + includes extension in format Grape::API - allows a(n) Hash json object in params + sets content type for json error + with a custom content_type Grape::API - allows a(n) String json object in params + sets content type Grape::API - allows a(n) Integer json object in params + sets content type for error + env["api.format"] Grape::API - stores input in api.request.input + uploads and downloads a PNG file via /attachment.png Grape::API - stores input in api.request.input + uploads and downloads a Ruby file Grape::API - stores input in api.request.input + uploads and downloads a PNG file via attachment + .route + plain Grape::API - stores input in api.request.input + provides access to route info + with desc Grape::API - allows a(n) Symbol json object in params + returns route parameters Grape::API - stores input in api.request.input - chunked transfer encoding + returns route description + custom middleware + .insert_before Grape::API - stores input in api.request.input - chunked transfer encoding + runs before a given middleware + .middleware Grape::API - stores input in api.request.input - chunked transfer encoding + includes middleware arguments from settings Grape::API - stores input in api.request.input - chunked transfer encoding + includes all middleware from stacked settings + .insert_after Grape::API - stores input in api.request.input - chunked transfer encoding + runs after a given middleware + .use Grape::API - stores input in api.request.input - chunked transfer encoding + adds middleware Grape::API - stores input in api.request.input - chunked transfer encoding + calls the middleware Grape::API - stores input in api.request.input - chunked transfer encoding + does not destroy the middleware settings on multiple runs Grape::API - stores input in api.request.input - chunked transfer encoding + does not show up outside the namespace Grape::API - stores input in api.request.input - allows HEAD on a GET request that + mounts behind error middleware Grape::API - has an empty body + adds a block if one is given Grape::API - returns a 200 - root routes should work with + uses a block if one is given + .prefix Grape::API - Accept-Version header versioned APIs + supports OPTIONS Grape::API - header versioned APIs with multiple headers + routes root through with the prefix Grape::API - unversioned APIs + routes through with the prefix Grape::API - header versioned APIs + disallows POST + cascading + via version Grape::API - param versioned APIs - path versioned APIs - when a single version provided + cascades Grape::API - with a format + does not cascade + via endpoint Grape::API - without a format - when array of versions provided + does not cascade Grape::API - is expected to eql "root" + cascades + .endpoints Grape::API - is expected to eql "root" - when hook behaviour is controlled by attributes on the route - when HTTP method is defined with attribute + adds one for each route created + with json default_error_formatter Grape::API - responds with the defined error in the before hook - when HEAD is called for the defined GET + returns json error + http_codes Grape::API - responds with 200 because before hooks are not called - when HTTP method is defined and the underlying before hook expectation is not met + presented with Grape::API - ends up in the endpoint - when HTTP method is not defined + is used as presenter + with non-UTF-8 characters in specified format Grape::API - responds with a 405 status - when HEAD is called for the defined GET + converts the characters + .rescue_from Grape::API - responds with 401 because before expectations in before hooks are not met - when HTTP method is defined and everything is like the before hooks expect + rescues only certain errors if rescue_from is called with specific errors Grape::API - ends up in the endpoint - adds an OPTIONS route for namespaced endpoints that +caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError + can rescue exceptions raised in the formatter Grape::API - has an empty body + mimics default ruby "rescue" handler Grape::API - has an Allow header + rescues all errors with a json formatter Grape::API - returns a 204 + uses default_rescue_handler to handle invalid response from rescue_from Grape::API - calls the outer before filter + rescues all errors if rescue_from :all is called Grape::API - calls the inner before filter + does not rescue errors when rescue_from is not set Grape::API - has no Content-Length + uses custom helpers defined by using #helpers method + with multiple apis + avoids polluting global namespace + CustomError subclass of Grape::Exceptions::Base Grape::API - has no Content-Type - when accessing env + rescues custom grape exceptions Grape::API - returns a 405 for an unsupported method - adds a 405 Not Allowed route that + does not re-raise exceptions of type Grape::Exceptions::Base + do_not_route_head! Grape::API - returns a 405 + options does not contain HEAD Grape::API - has a X-Custom-Header + does not allow HEAD on a GET request + routes + api with a custom route setting Grape::API - contains error message in body + exposed + status Grape::API - has an Allow header - when format is xml + can be set with a status code symbol Grape::API - returns a 405 for an unsupported method - adds an OPTIONS route that + can be set to arbitrary Integer value + empty api structure Grape::API - calls before hook + returns an empty array of routes + api structure with multiple apis Grape::API - has no Content-Length + sets params + api structure with an api without params Grape::API - does not call before_validation hook + sets params + api structure with additional parameters Grape::API - has no Content-Type + splits a string Grape::API - has an empty body + splits a string with limit Grape::API - returns a 204 + sets params + single method api structure Grape::API - calls after hook + returns one route + api structure with two versions and a namespace Grape::API - does not call after_validation hook + sets route versions Grape::API - has an Allow header - post + sets route paths Grape::API - allows a(n) TrueClass json object in params + returns versions Grape::API - stores input in api.request.input + sets a nested namespace Grape::API - allows a(n) NilClass json object in params + sets prefix Grape::API - stores input in api.request.input + returns the latest version set + .rescue_from klass, rescue_subclasses: boolean Grape::API - stores input in api.request.input + rescues error as well as subclass errors with rescue_subclasses option set Grape::API - allows a(n) Integer json object in params + sets rescue_subclasses to true by default Grape::API - allows a(n) FalseClass json object in params + does not rescue child errors if rescue_subclasses is false + .rescue_from klass, lambda Grape::API - allows a(n) Symbol json object in params + can execute the lambda with an argument Grape::API - stores input in api.request.input + rescues an error with the lambda + .version using path + behaves like versioning Grape::API - allows a(n) Array json object in params + adds the prefix before the API version Grape::API - stores input in api.request.input + is able to specify version as a nesting Grape::API - allows a(n) Float json object in params + sets the API version Grape::API - stores input in api.request.input + does not overwrite version parameter with API version Grape::API - stores input in api.request.input + is able to specify multiple versions + with catch-all + v1 Grape::API - stores input in api.request.input + finds endpoint Grape::API - allows a(n) Hash json object in params + finds catch all + v2 Grape::API - allows a(n) String json object in params + finds endpoint Grape::API - stores input in api.request.input - chunked transfer encoding + finds catch all + with different versions for the same endpoint + with a prefix Grape::API - stores input in api.request.input - chunked transfer encoding + allows the same endpoint to be implemented + without a prefix Grape::API - stores input in api.request.input - chunked transfer encoding + allows the same endpoint to be implemented + with before block defined within a version block Grape::API - stores input in api.request.input - chunked transfer encoding + calls before block that is defined within the version block + .endpoint Grape::API - stores input in api.request.input - chunked transfer encoding + path + .version + when defined Grape::API - stores input in api.request.input - chunked transfer encoding + returns version value + when not defined Grape::API - stores input in api.request.input - chunked transfer encoding + returns nil + .compile! Grape::API - stores input in api.request.input - chunked transfer encoding + compiles the instance for rack! Grape::API - stores input in api.request.input - chunked transfer encoding + requires the grape/eager_load file + .error_format Grape::API - stores input in api.request.input - .mount - mounting an API + rescues all errors and return :txt Grape::API - collects the routes of the mounted api + rescues all errors and return :txt with backtrace Grape::API - applies the settings to nested mounted apis + rescues error! and return txt Grape::API - applies format to a mounted API with nested resources + rescues all errors and return :json Grape::API - responds to options with path versioning + rescues all errors with a default formatter Grape::API - applies the settings of the mounting api + rescues all errors and return :json with backtrace Grape::API - recognizes potential versions with mounted path + defaults the error formatter to format + class Grape::API - mounts a versioned API with nested resources + returns a custom error format + with json format Grape::API - responds to options + rescues error! called with a string and returns json Grape::API - mounts multiple versioned APIs with nested resources + rescues error! called with a symbol and returns json Grape::API - applies auth to a mounted API with nested resources + rescues error! called with a hash 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 Grape::API - mounts on a path + returns a custom error format + const_missing + raises an error + .content_type Grape::API - mounts a prefixed API with nested resources + removes existing content types Grape::API - mounts on a nested path - when mounting class extends a subclass of Grape::API - mounts APIs with the same superclass - when some rescues are defined by mounted + allows to override content-type Grape::API - prefers more specific rescues defined by mounted + sets additional content-type + .route_param Grape::API - inherits parent rescues + adds a parameterized route segment namespace Grape::API - prefers rescues defined by mounted even if outer is more specific + defines requirements with a single hash + with param type definitions Grape::API - prefers rescues defined by mounted if they rescue similar error class - when including a module - correctlies include module in nested mount + is used by passing to options + lifecycle + when the api_call has a controlled error +Grape::API + follows the errored life_cycle (skips after) + when the api_call has an exception +Grape::API + follows the errored life_cycle (skips after) + when the api_call succeeds +Grape::API + follows the standard life_cycle + when the api_call fails validation +Grape::API + follows the failed_validation cycle (skips after_validation, api_call & after) + .mount without a hash Grape::API calls through setting the route to "/" with a bare rack app Grape::API - is able to cascade -Grape::API anchors the routes, passing all subroutes to it Grape::API makes a bare Rack app available at the endpoint - .version - when defined Grape::API - returns version value - when not defined + is able to cascade + mounting an API Grape::API - returns nil - .rescue_from klass, with: :method_name + mounts on a path Grape::API - correctly chooses exception handler if :all handler is specified + collects the routes of the mounted api Grape::API - rescues an error with the specified method name + responds to options Grape::API - aborts if the specified method name does not exist - body - plain text + mounts a prefixed API with nested resources Grape::API - returns blank body - false + applies the settings to nested mounted apis Grape::API - returns blank body - .compile! + applies auth to a mounted API with nested resources Grape::API - compiles the instance for rack! + applies format to a mounted API with nested resources Grape::API - requires the grape/eager_load file - .rescue_from klass, lambda + mounts multiple versioned APIs with nested resources Grape::API - rescues an error with the lambda + mounts on a nested path Grape::API - can execute the lambda with an argument - .format - :json + applies the settings of the mounting api Grape::API - forces json from a non-accepting header + recognizes potential versions with mounted path Grape::API - forces json without an extension + responds to options with path versioning Grape::API - can be overwritten with an explicit content type + mounts a versioned 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 - does not force json with an extension + inherits parent rescues Grape::API - raised :error from middleware - :txt only + prefers more specific rescues defined by mounted Grape::API - forces txt without an extension + prefers rescues defined by mounted even if outer is more specific Grape::API - does not accept extensions other than specified + prefers rescues defined by mounted if they rescue similar error class + .http_basic Grape::API - accepts specified extension + protects any resources on the same scope Grape::API - forces txt from a non-accepting header - :xml + has access to the current endpoint Grape::API - string + has access to helper methods Grape::API - hash + is scopable +Grape::API + is callable via .auth as well +Grape::API + can set instance variables accessible to routes + .helpers +Grape::API + is accessible from the endpoint +Grape::API + allows for modules +Grape::API + allows multiple calls with modules and blocks +Grape::API + is scopable +Grape::API + is reopenable + .format + :xml Grape::API raised :error from middleware Grape::API array +Grape::API + hash +Grape::API + string + :json +Grape::API + can be overwritten with an explicit content type +Grape::API + forces json without an extension +Grape::API + forces json from a non-accepting header +Grape::API + does not force json with an extension +Grape::API + raised :error from middleware :serializable_hash Grape::API array Grape::API - instance -Grape::API root +Grape::API + instance :txt Grape::API + forces txt without an extension +Grape::API forces txt from a non-accepting header Grape::API does not force txt with an extension + :txt only +Grape::API + does not accept extensions other than specified +Grape::API + accepts specified extension Grape::API forces txt without an extension - .version using path +Grape::API + forces txt from a non-accepting header + custom route helpers on nested APIs + returns the given id when it is valid + returns an error when the id is bad + .rescue_from :grape_exceptions +Grape::API + rescues grape exceptions with a user-defined handler +Grape::API + rescues grape exceptions + .scope +Grape::API + scopes the various settings + .insert +Grape::API + inserts middleware in a specific location in the stack + .version using param behaves like versioning Grape::API is able to specify multiple versions Grape::API - sets the API version -Grape::API is able to specify version as a nesting Grape::API adds the prefix before the API version Grape::API + sets the API version +Grape::API does not overwrite version parameter with API version with before block defined within a version block Grape::API calls before block that is defined within the version block with catch-all - v2 -Grape::API - finds endpoint + v1 Grape::API finds catch all - v1 +Grape::API + finds endpoint + v2 Grape::API finds catch all Grape::API @@ -2717,513 +2746,418 @@ with a prefix Grape::API allows the same endpoint to be implemented - routes - api structure with an api without params -Grape::API - sets params - single method api structure -Grape::API - returns one route - empty api structure -Grape::API - returns an empty array of routes - api structure with multiple apis -Grape::API - sets params - status -Grape::API - can be set to arbitrary Integer value -Grape::API - can be set with a status code symbol - api with a custom route setting -Grape::API - exposed - api structure with additional parameters -Grape::API - splits a string -Grape::API - splits a string with limit -Grape::API - sets params - api structure with two versions and a namespace -Grape::API - sets route versions -Grape::API - returns the latest version set -Grape::API - sets route paths -Grape::API - returns versions -Grape::API - sets a nested namespace -Grape::API - sets prefix - .content_type + .configure Grape::API - allows to override content-type + allows configuring the api + when not given a block Grape::API - sets additional content-type + returns a configuration object + when given a block Grape::API - removes existing content types - .error_format + calls the block passing the config Grape::API - rescues all errors with a default formatter + returns self + with unsafe HTML format specified Grape::API - rescues error! and return txt + escapes the HTML + .change! Grape::API - rescues all errors and return :json with backtrace + invalidates any compiled instance + body + false Grape::API - defaults the error formatter to format + returns blank body + plain text Grape::API - rescues all errors and return :txt with backtrace + returns blank body + .version using header + behaves like versioning Grape::API - rescues all errors and return :json + is able to specify multiple versions Grape::API - rescues all errors and return :txt - with json format + is able to specify version as a nesting Grape::API - rescues error! called with a hash and returns json + does not overwrite version parameter with API version Grape::API - rescues error! called with a string and returns json + adds the prefix before the API version Grape::API - rescues error! called with a symbol and returns json - with - class + sets the API version + with catch-all + v2 Grape::API - 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 + finds endpoint Grape::API - returns a custom error format - .logger + finds catch all + v1 Grape::API - does not unnecessarily retain duplicate setup blocks + finds catch all Grape::API - returns an instance of Logger class by default - with a custom logger - exposes its interaface - .represent + finds endpoint + with before block defined within a version block Grape::API - requires a :with option + calls before block that is defined within the version block + with different versions for the same endpoint + without a prefix Grape::API - adds the association to the :representations setting - .scope + allows the same endpoint to be implemented + with a prefix Grape::API - scopes the various settings + allows the same endpoint to be implemented + .inherited + does not override methods inherited from Class + overriding within class + allows overriding the hook + overriding via composition + allows overriding the hook .parser Grape::API parses data in format requested by content-type - custom parser class -Grape::API - uses custom parser - none parser class -Grape::API - does not parse data - multi_xml -Grape::API - doesn't parse yaml lambda parser Grape::API uses parser for text/custom Grape::API uses parser for text/custom; charset=UTF-8 - custom route helpers on nested APIs - returns an error when the id is bad - returns the given id when it is valid - with json default_error_formatter + multi_xml Grape::API - returns json error - .default_error_status + doesn't parse yaml + none parser class Grape::API - uses the default error status in error! + does not parse data + custom parser class Grape::API - allows setting default_error_status + uses custom parser + .finally + when the ensure block has no exceptions + when a handled error occurs inside the API call Grape::API - has a default error status - filters + executes the ensure code + when no API call is made Grape::API - adds a before filter + has not executed the ensure code + when no errors occurs Grape::API - adds a before filter to current and child namespaces only + executes the ensure code + with a helper Grape::API - adds a after_validation filter + has access to the helper + when an unhandled occurs inside the API call Grape::API - calls all filters when validation passes + executes the ensure code + .rescue_from klass, block Grape::API - calls only before filters when validation fails + rescues Exception + custom errors Grape::API - calls filters in the correct order + rescues a subclass of an error by default Grape::API - adds a after filter - const_missing - raises an error - do_not_route_head! + rescues an error via rescue_from :all Grape::API - options does not contain HEAD + rescues a specific error Grape::API - does not allow HEAD on a GET request - .endpoint + rescues multiple specific errors Grape::API - path - .endpoints + does not rescue a different error + .rescue_from klass, with: :method_name Grape::API - adds one for each route created - custom middleware - .middleware + correctly chooses exception handler if :all handler is specified Grape::API - includes middleware arguments from settings + aborts if the specified method name does not exist Grape::API - includes all middleware from stacked settings - .use + rescues an error with the specified method name + .route Grape::API - adds a block if one is given + runs all filters and body with a custom OPTIONS method Grape::API - adds middleware + returns a 201 response code for POST by default Grape::API - does not show up outside the namespace + allows and properly constrain a OPTIONS method Grape::API - does not destroy the middleware settings on multiple runs + allows and properly constrain a HEAD method Grape::API - uses a block if one is given + runs only the before filter on 405 bad method Grape::API - calls the middleware + allows for catch-all in a namespace Grape::API - mounts behind error middleware - .insert_before + allows and properly constrain a PATCH method Grape::API - runs before a given middleware - .insert_after + allows for multiple paths Grape::API - runs after a given middleware - .rescue_from + handles empty calls Grape::API -caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError - can rescue exceptions raised in the formatter + allows for no path Grape::API - rescues all errors with a json formatter + 405 responses includes an Allow header specifying supported methods Grape::API - rescues all errors if rescue_from :all is called + allows and properly constrain a PUT method Grape::API - rescues only certain errors if rescue_from is called with specific errors + allows and properly constrain a POST method Grape::API - uses custom helpers defined by using #helpers method + allows for multiple verbs Grape::API - does not rescue errors when rescue_from is not set + overwrites the default HEAD request Grape::API - mimics default ruby "rescue" handler + allows for :any as a verb Grape::API - uses default_rescue_handler to handle invalid response from rescue_from - with multiple apis - avoids polluting global namespace - CustomError subclass of Grape::Exceptions::Base + allows and properly constrain a DELETE method Grape::API - does not re-raise exceptions of type Grape::Exceptions::Base + runs before filter exactly once on 405 bad method Grape::API - rescues custom grape exceptions - .insert + allows for multipart paths Grape::API - inserts middleware in a specific location in the stack - .prefix + allows for format in namespace with no path Grape::API - routes through with the prefix + allows for format without corrupting a param Grape::API - routes root through with the prefix + allows and properly constrain a GET method Grape::API - supports OPTIONS + returns a 405 for an unsupported method with an X-Custom-Header Grape::API - disallows POST - .formatter - custom formatter class + 405 responses includes an Content-Type header + when hook behaviour is controlled by attributes on the route + when HTTP method is not defined Grape::API - uses json + responds with a 405 status + when HTTP method is defined and the underlying before hook expectation is not met Grape::API - uses custom formatter - custom formatter + ends up in the endpoint + when HTTP method is defined and everything is like the before hooks expect Grape::API - uses json + ends up in the endpoint + when HEAD is called for the defined GET Grape::API - uses custom formatter - multiple formatters + responds with 200 because before hooks are not called + when HTTP method is defined with attribute Grape::API - sets one formatter + responds with the defined error in the before hook + when HEAD is called for the defined GET Grape::API - sets another formatter - normal class methods - can find the appropiate name - is equal to itself - .rescue_from klass, rescue_subclasses: boolean + responds with 401 because before expectations in before hooks are not met + adds an OPTIONS route that Grape::API - does not rescue child errors if rescue_subclasses is false + has an empty body Grape::API - rescues error as well as subclass errors with rescue_subclasses option set + calls before hook Grape::API - sets rescue_subclasses to true by default - .version using param - behaves like versioning + returns a 204 Grape::API - is able to specify multiple versions + has no Content-Length Grape::API - sets the API version + does not call before_validation hook Grape::API - adds the prefix before the API version + has an Allow header Grape::API - does not overwrite version parameter with API version + does not call after_validation hook Grape::API - is able to specify version as a nesting - with before block defined within a version block + calls after hook Grape::API - calls before block that is defined within the version block - with catch-all - v2 + has no Content-Type + when format is xml Grape::API - finds endpoint + returns a 405 for an unsupported method + root routes should work with Grape::API - finds catch all - v1 + param versioned APIs Grape::API - finds endpoint + Accept-Version header versioned APIs Grape::API - finds catch all - with different versions for the same endpoint - with a prefix + header versioned APIs Grape::API - allows the same endpoint to be implemented - without a prefix + unversioned APIs Grape::API - allows the same endpoint to be implemented - .rescue_from :grape_exceptions + header versioned APIs with multiple headers + path versioned APIs + when array of versions provided Grape::API - rescues grape exceptions with a user-defined handler + is expected to eql "root" Grape::API - rescues grape exceptions - .rescue_from klass, block + is expected to eql "root" + when a single version provided Grape::API - rescues Exception - custom errors + without a format Grape::API - rescues an error via rescue_from :all + with a format + when a resource routes by POST, GET, PATCH, PUT, and DELETE + it adds an OPTIONS route for namespaced endpoints that Grape::API - does not rescue a different error + has an empty body Grape::API - rescues a specific error + has an Allow header Grape::API - rescues a subclass of an error by default + returns a 204 + adds a 405 Not Allowed route that Grape::API - rescues multiple specific errors - format + contains error message in body Grape::API - does not include extension in id + has an Allow header Grape::API - sets content type for txt format + returns a 405 Grape::API - does not set Cache-Control + has a X-Custom-Header + adds an OPTIONS route for namespaced endpoints that 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 + returns a 204 Grape::API - sets content type for json + calls the outer before filter Grape::API - sets content type for xml error + has no Content-Length Grape::API - streams the content of the file with stream + has an empty body Grape::API - includes extension in format + has no Content-Type Grape::API - sets content type for binary format + has an Allow header Grape::API - returns raw data when content type binary + calls the inner before filter + allows HEAD on a GET request that Grape::API - sets content type for xml + returns a 200 Grape::API - sets content type for serializable hash format + has an empty body + format Grape::API - sets content type for json error + allows .txt Grape::API - sets content type for error - env["api.format"] + allows .json + put Grape::API - uploads and downloads a PNG file via attachment + allows a(n) Hash json object in params Grape::API - uploads and downloads a Ruby file + allows a(n) Integer json object in params Grape::API - uploads and downloads a PNG file via /attachment.png - with a custom content_type + stores input in api.request.input Grape::API - sets content type + allows a(n) Symbol json object in params Grape::API - sets content type for error - cascading - via endpoint + stores input in api.request.input Grape::API - cascades + allows a(n) Float json object in params Grape::API - does not cascade - via version + allows a(n) FalseClass json object in params Grape::API - cascades + stores input in api.request.input Grape::API - does not cascade - desc + stores input in api.request.input Grape::API - uses full name of parameters in nested groups + stores input in api.request.input Grape::API - allows to set the type attribute on :group element + allows a(n) TrueClass json object in params 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 + allows a(n) String json object in params Grape::API - empty array of routes + allows a(n) NilClass json object in params Grape::API - parses parameters when no description is given + stores input in api.request.input Grape::API - does not symbolize params + allows a(n) Array json object in params Grape::API - merges the parameters of the namespace with the parameters of the method + stores input in api.request.input Grape::API - empty array of routes + stores input in api.request.input Grape::API - resets desc + stores input in api.request.input + chunked transfer encoding Grape::API - includes details + stores input in api.request.input + chunked transfer encoding 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 + stores input in api.request.input + chunked transfer encoding Grape::API - does not inherit param descriptions in consequent namespaces + stores input in api.request.input + chunked transfer encoding Grape::API - groups nested params and prevents overwriting of params with same name in different groups + stores input in api.request.input + chunked transfer encoding Grape::API - merges the parameters of nested namespaces + stores input in api.request.input + chunked transfer encoding Grape::API - describes methods separately + stores input in api.request.input + chunked transfer encoding Grape::API - describes a method with parameters + stores input in api.request.input + chunked transfer encoding Grape::API - has params which does not include format and version as named captures - .route - plain + stores input in api.request.input + chunked transfer encoding Grape::API - provides access to route info - with desc + stores input in api.request.input + post Grape::API - returns route parameters + stores input in api.request.input Grape::API - returns route description - .default_format + allows a(n) String json object in params Grape::API - returns data in default format + stores input in api.request.input Grape::API - parses data in default format - do_not_route_options! + allows a(n) Integer json object in params Grape::API - does not include OPTIONS in Allow header + allows a(n) TrueClass json object in params Grape::API - does not create an OPTIONS route - lifecycle - when the api_call fails validation + stores input in api.request.input Grape::API - follows the failed_validation cycle (skips after_validation, api_call & after) - when the api_call succeeds + stores input in api.request.input Grape::API - follows the standard life_cycle - when the api_call has an exception + allows a(n) NilClass json object in params Grape::API - follows the errored life_cycle (skips after) - when the api_call has a controlled error + allows a(n) Hash json object in params Grape::API - follows the errored life_cycle (skips after) - .helpers + allows a(n) Float json object in params Grape::API - allows for modules + allows a(n) Symbol json object in params Grape::API - is scopable + allows a(n) Array json object in params Grape::API - is accessible from the endpoint + stores input in api.request.input Grape::API - allows multiple calls with modules and blocks + allows a(n) FalseClass json object in params Grape::API - is reopenable - .finally - when the ensure block has no exceptions - when no API call is made + stores input in api.request.input Grape::API - has not executed the ensure code - when no errors occurs + stores input in api.request.input Grape::API - executes the ensure code - with a helper + stores input in api.request.input Grape::API - has access to the helper - when a handled error occurs inside the API call + stores input in api.request.input + chunked transfer encoding Grape::API - executes the ensure code - when an unhandled occurs inside the API call + stores input in api.request.input + chunked transfer encoding Grape::API - executes the ensure code - catch-all + stores input in api.request.input + chunked transfer encoding Grape::API - anchor=false + stores input in api.request.input + chunked transfer encoding Grape::API - anchor=true - .route_param + stores input in api.request.input + chunked transfer encoding Grape::API - adds a parameterized route segment namespace + stores input in api.request.input + chunked transfer encoding Grape::API - defines requirements with a single hash - with param type definitions + stores input in api.request.input + chunked transfer encoding Grape::API - is used by passing to options - http_codes + stores input in api.request.input + chunked transfer encoding Grape::API - is used as presenter + stores input in api.request.input + chunked transfer encoding Grape::API - presented with - .compile + stores input in api.request.input + when accessing env Grape::API - sets the instance - .version using header + returns a 405 for an unsupported method + .version using accept_version_header behaves like versioning Grape::API does not overwrite version parameter with API version Grape::API sets the API version Grape::API - is able to specify multiple versions -Grape::API - is able to specify version as a nesting -Grape::API - adds the prefix before the API version - with catch-all - v1 -Grape::API - finds endpoint -Grape::API - finds catch all - v2 -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 - with different versions for the same endpoint - with a prefix -Grape::API - allows the same endpoint to be implemented - without a prefix -Grape::API - allows the same endpoint to be implemented - .version using accept_version_header - behaves like versioning -Grape::API - does not overwrite version parameter with API version -Grape::API is able to specify version as a nesting Grape::API - sets the API version -Grape::API adds the prefix before the API version Grape::API is able to specify multiple versions @@ -3240,1043 +3174,1291 @@ with catch-all v2 Grape::API - finds endpoint -Grape::API - finds catch all - v1 -Grape::API finds catch all Grape::API finds endpoint - .inherited - does not override methods inherited from Class - overriding within class - allows overriding the hook - overriding via composition - allows overriding the hook - .namespace -Grape::API - `.resource` is an alias -Grape::API - accepts path segments correctly -Grape::API - `.resources` is an alias -Grape::API - is stackable -Grape::API - comes after the prefix and version -Grape::API - is callable with nil just to push onto the stack -Grape::API - `.segment` is an alias -Grape::API - is retrievable and converted to a path + v1 Grape::API - `.group` is an alias + finds endpoint Grape::API - cancels itself after the block is over + finds catch all + normal class methods + is equal to itself + can find the appropiate name -Grape::Util::InheritableValues - #clone - complex (i.e. not primitive) data types (ex. entity classes, please see bug #891) - copies values; does not duplicate them +MultiJson + uses multi_json (PENDING: Temporarily skipped with xit) + +Grape::Exceptions::InvalidAcceptHeader + 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 with status 200 + does return the expected result + that receives + 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 + 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 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=true, http_codes but without a rescue 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 the expected result + does return with status 200 + 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=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 + 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 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 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 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 + +Grape::Exceptions::MissingMimeType + #message + contains the problem in the message + contains the resolution in the message + +Grape::Validations::Types::SetCoercer + #call + a set of sets of arrays + coerces elements in the nested set + a set of sets + coerces elements in the nested set + a set of primitives + coerces elements to the set + +Grape::Util::StackableValues + #[] + combines parent and actual values + returns parent value when no value is set + returns an array of values + parent values are not changed #to_hash returns a Hash representation + #keys + returns merged keys with parent + returns all keys + #clone + copies all values + complex (i.e. not primitive) data types (ex. middleware, please see bug #930) + copies values; does not duplicate them #[]= + pushes further values + can handle array values sets a value #delete does not delete parent values deletes a key - #[] - returns parent value when no value is set - overwrites parent value with the current one - parent values are not changed - returns a value -Grape::Extensions::Hashie::Mash::ParamBuilder - in an api - is indifferent to key or symbol access - #params - is Hashie::Mash - in a nested namespace api - is Hashie::Mash - in an endpoint - #params - is of type Hashie::Mash +Validator with instance variables + passes validation every time -Grape::API - an endpoint without documentation - does not document parameters for the endpoint - still declares params internally - an endpoint with documentation - allows documentation with a hash - documents parameters +Grape::API::Helpers + defines parameters + +Grape::Endpoint + get + routes to namespace and path params with dots, with merged requirements + routes to a path with multiple params with dots + routes to a namespace param with dots + routes to namespace and path params with dots, with overridden requirements + +Grape::DSL::Settings + #namespace_inheritable + inherits values from surrounding namespace + delegates to get_or_set + #unset_namespace_inheritable + delegates to unset + #unset_namespace_setting + delegates to unset + #within_namespace + calls start and end for a namespace + returns the last result + #global_setting + delegates to get_or_set + #get_or_set + sets a values + returns a value when nil is new value is provided + complex scenario + plays well + #unset_namespace_stackable + delegates to unset + #unset_api_class_setting + delegates to unset + #namespace_setting + resets values after leaving nested namespaces + delegates to get_or_set + sets a value until the end of a namespace + #namespace_stackable + stacks values from surrounding namespace + delegates to get_or_set + #route_setting + delegates to get_or_set + sets a value until the next route + #unset_global_setting + delegates to unset + #unset_route_setting + delegates to unset + #unset + deletes a key from settings + #api_class_setting + delegates to get_or_set + +MultiXml + uses multi_xml + +Grape::Middleware::Stack + #concat + adds non :use specs to @others + calls +merge_with+ with the :use specs + #insert_after + inserts a middleware after another middleware class + inserts a middleware after an anonymous class given by its superclass + raises an error on an invalid index + #insert + inserts a middleware class at the integer index + #merge_with + applies a collection of operations and middlewares + middleware spec with proc declaration exists + properly forwards spec arguments + #build + returns a rack builder instance + when @others are present + applies the middleware specs stored in @others + #use + pushes a middleware class onto the stack + pushes a middleware class with arguments onto the stack + pushes a middleware class with block arguments onto the stack + #insert_before + inserts a middleware before another middleware class + raises an error on an invalid index + inserts a middleware before an anonymous class given by its superclass + +Grape::DSL::Logger + .logger + returns a logger + sets a logger + +Grape::Validations::MultipleAttributesIterator + #each + when params is empty optional placeholder + does not yield it + when params is a hash + yields the whole params hash without the list of attrs + when params is an array + yields each element of the array without the list of attrs + +Grape::Util::InheritableSetting + #api_class + is specific to the class + #global + sets a global value + handles different parents + overrides global values + sets the global inherited values + #namespace + sets a value until the end of a namespace + uses new values when a new namespace starts + #route + sets a value until the next route + works with route values + #namespace_inheritable + works with inheritable values + handles different parents + #point_in_time_copy + decouples namespace stackable values + decouples namespace inheritable values + adds itself to original as clone + resets point_in_time_copies + decouples namespace values + decouples namespace reverse stackable values + decouples route values + #namespace_reverse_stackable + works with reverse stackable values + #to_hash + return all settings as a hash + #inherit_from + notifies clones + #namespace_stackable + works with stackable values + #api_class + is specific to the class + +Grape::API::Helpers + defines parameters + +Grape::Endpoint + sets itself in the env upon call + resets all instance variables (except block) between calls + does not persist params between calls + allows explicit return calls + 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 + when terminating the response with error! + breaks normal call chain + allows prior and parent filters of same type to run + before filters + runs the before filter if set + #redirect + redirects to a url with status 302 + 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 + 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 + #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 + is available to the caller + deeply converts nested params + parses from path segments + does not accept text/plain in JSON format if application/json is specified as content type + responds with a 415 for an unsupported content-type + content type with params + responses with given content type in headers + does not response with 406 for same type without params + sets a value to params + params + precedence + route string params have higher precedence than body params + route string params have higher precedence than URL params + from body parameters + converts XML bodies to params + converts JSON bodies to params + converts XML bodies to params + does not convert empty JSON bodies to params + returns a 400 if given an invalid multipart body + does not include parameters not defined by the body + with special requirements + parses many params with provided regexps + parses email param with provided requirements for params + namespace requirements + parse email param with provided requirements for params + overrides outer namespace's requirements + when the limit on multipart files is exceeded + returns a 413 if given too many multipart files + request + includes prefix + is set to the url requested + includes version v1 + includes version v1 + #header + is callable from within a block + #error! + sets the status code for the endpoint + merges additional headers with headers set before call + accepts a frozen object + can specifiy headers + accepts a code + does not merges additional headers with headers set after call + accepts a message + accepts an object and render it in format + version headers + result in a 406 response if they are invalid + result in a 406 response if they cannot be parsed by rack-accept + #cookies + sets browser cookies and does not set response cookies + deletes cookies with path + sets and update browser cookies + deletes cookie + is callable from within a block + anchoring + 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 + anchors paths by default for the GET method + allows for the anchoring option with a OPTIONS method + responds to /example/and/some/more for the non-anchored POST method + allows for the anchoring option with a GET method + responds to /example/and/some/more for the non-anchored PUT method + anchors paths by default for the POST method + allows for the anchoring option with a HEAD method + responds to /example/and/some/more for the non-anchored OPTIONS method + 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 PATCH method + anchors paths by default for the PUT method + allows for the anchoring option with a POST method + anchors paths by default for the HEAD method + responds to /example/and/some/more for the non-anchored PATCH method + allows for the anchoring option with a PUT method + responds to /example/and/some/more for the non-anchored HEAD method + delete 204 + anchors paths by default for the delete method + allows for the anchoring option with a delete method + 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 + delete 200, with response body + responds to /example/and/some/more for the non-anchored delete method + #headers + includes headers passed as symbols + includes additional request headers + includes request headers + #params + sets a value to params + params + default class + is a ActiveSupport::HashWithIndifferentAccess + #initialize + takes a settings stack, options, and a block + .before_each + is settable via block + is able to stack helper + is settable via reference + is able to override a helper + validation errors + returns the errors, and passes headers + instrumentation + notifies AS::N + #status + is callable from within a block + is set as default to 200 for get + is set as default to 201 for post + .generate_api_method + raises NameError if the method name is already in use + returns a Proc + raises ArgumentError if a block is not given Grape::Validations 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 - required with a Hash block - errors when param not present - adds to declared parameters - doesn't throw a missing param when param is present - errors when nested param not present - errors when param is not a Hash - requires with nested params - validates correctly in deep nested params - optional with an Array block - doesn't throw a missing param when the group isn't present - adds to declared parameters - 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 - with block and keyword argument - works - requires :all using Grape::Entity documentation - errors when required_field is not present - works when required_field is present - adds entity documentation to declared params - named - can be included in usual params - by #use - by #use with multiple params - with block - overrides default value for order_by - fails with invalid value - overrides default value for order - returns defaults - can be defined - in helper module which kind of Grape::DSL::Helpers::BaseHelper - in helpers - optional using Grape::Entity documentation - works when field_a and field_b are not present - adds entity documentation to declared params - works when field_b is present - works when field_a is present - multiple validation errors - throws the validation errors - validation within arrays with JSON - safely handles empty arrays and blank parameters - errors when a parameter is not present - can handle new scopes within child elements - 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 - doesn't throw an error if the validation passes - errors if the validation fails - with block param - requires defaults to Array type - optional defaults to Array type - group defaults to Array type - requires :all or :none but except a non-existent field using Grape::Entity documentation - requires :all - adds only the entity documentation to declared params, nothing more - requires :none - adds only the entity documentation to declared params, nothing more - validation within arrays - errors when param is not an Array - safely handles empty arrays and blank parameters - can handle new scopes within child elements - errors when a parameter is not present in array within array - errors when a parameter is not present - handle errors for all array elements + at least one of + params + does not error when one is present + errors when none are present + does not error when two are present + with a custom validation message + errors when none are present + does not error when two are present + does not error when one is present + nested params + does not error when one is present + errors when none are present + does not error when two are present custom validation when using requires with a custom validator validates when param is not present validates when param is present nested namespaces 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 peer namespaces does not have the validator - namespaces nested in peers should also not have the validator the nested namespace inherits the custom validator when using optional with a custom validator - validates when param is present skips validation when parameter isn't present + validates when param is present validates with custom validator when param present and incorrect type when using options on param validates param with custom validator with options - group - doesn't throw a missing param when param is present - adds to declared parameters - errors when param not present + optional using Grape::Entity documentation + works when field_a is present + works when field_a and field_b are not present + works when field_b is present + adds entity documentation to declared params + group params with nested params which has a type + errors when group param is invalid in a group + errors when no parameter from the set is present 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 works when only one from the set is present - errors when no parameter from the set is present - hash with a required param with validation - works when all params match - errors when param is not a Hash with block and empty args works - exactly one of - params - errors when two or more are present - succeeds when one is 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 - nested params - errors when none are present - succeeds when one is present - errors when two or more are present - required with an Array and a Hash block - does not output index [0] for Hash types all or none optional params with a custom validation message errors when any one is present - works when all params are present works when none are present + works when all params are present + requires with nested params + validates correctly in deep nested params nested optional Array blocks + exactly_one_of does internal validations if the outer group is present + adds to declared parameters + handles deep nesting + handles validation within arrays does no internal validations if the outer group is blank all_or_none_of - handles validation within arrays - adds to declared parameters - exactly_one_of at_least_one_of - handles deep nesting 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 -> Array -> Hash -> String + example based off actual real world use case 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 valid data with invalid data - at least one of - params - does not error when two are present - errors when none are present - does not error when one is present - with a custom validation message - does not error when two are present - errors when none are present - does not error when one is present - nested params - does not error when one is present - does not error when two are present - errors when none are present - group params with nested params which has a type - errors when group param is invalid - optional - doesn't validate when param not present - validates when params is present + custom validator for a Hash + which is optional + errors if the validation fails + doesn't throw an error if the validation passes + which is required + doesn't throw an error if the validation passes + errors if the validation fails + hash with a required param with validation + errors when param is not a Hash + works when all params match + 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 + errors when param not present + doesn't throw a missing param when param is present + works when required field is present but nil adds to declared parameters - required with an Array block + requires :none using Grape::Entity documentation + adds entity documentation to declared params + works when required_field is present + errors when required_field is not present + required with a Hash block doesn't throw a missing param when param is present adds to declared parameters + errors when param is not a Hash errors when param not present + errors when nested param not present + required with an Array block doesn't throw a missing param when param is present but empty - errors when param is not an Array - required - works when required field is present but nil + errors when param not present doesn't throw a missing param when param is present adds to declared parameters - errors when param not present + errors when param is not an Array + exactly one of + nested params + errors when none are present + errors when two or more are present + succeeds when one is present + params + errors when none are present + succeeds when one is present + errors when two or more are present + with a custom validation message + errors when none are present + succeeds when one is present + errors when two or more are present + optional with an Array block + doesn't throw a missing param when both group and param are given + errors when group is present, but required param is not + errors when param is present but isn't an Array + doesn't throw a missing param when the group isn't present + adds to declared parameters + validation within arrays + errors when a parameter is not present in array within array + handle errors for all array elements + errors when param is not an Array + can handle new scopes within child elements + safely handles empty arrays and blank parameters + errors when a parameter is not present + with block param + optional defaults to Array type + requires defaults to Array type + group defaults to Array type + with block and keyword argument + works + optional + adds to declared parameters + validates when params is present + doesn't validate when param not present mutually exclusive - 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 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 more than one set of mutually exclusive params errors for all sets with a custom validation message errors for all sets - mutually exclusive params inside Hash group - invalidates if request param is invalid type + group + adds to declared parameters + errors when param not present + doesn't throw a missing param when param is present + required with an Array and a Hash block + does not output index [0] for Hash types + named + can be included in usual params + by #use with multiple params + by #use + can be defined + in helper module which kind of Grape::DSL::Helpers::BaseHelper + in helpers + with block + overrides default value for order + returns defaults + fails with invalid value + overrides default value for order_by + multiple validation errors + throws the validation errors + 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 + requires :all using Grape::Entity documentation + errors when required_field is not present + adds entity documentation to declared params + works when required_field is present require_validator when found is expected to equal Grape::Validations::Validators::PresenceValidator when not found raises an error -Grape::Request - #headers - with non-HTTP_* stuff in env - does not include them - with http headers in env - cuts HTTP_ prefix and capitalizes header name words - with symbolic header names - converts them to string - 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 - #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 +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 disabled + does not document attributes + 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 + behaves like an optional doc attribute + does not mention it + the description key instead of desc + adds the given description + nil as a default value + is still documented + false 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 -Grape::Validations::SingleAttributeIterator - #each - when params is an array - yields every single attribute from the list for each of the array elements - empty values - marks params with empty values - when missing optional value - does not yield skipped values - when params is a hash - yields params and every single attribute from the list +Grape + .config + is expected to eq {:param_builder=>Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder} -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 specified versions as [:v1, "v2"] - allows versions that have been specified - throws an error if a non-allowed version is specified - with a pattern - ignores the version if it fails to match - sets the version if it matches - with mount path - 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 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 +Grape::DSL::Routing + .version + sets a version for route + .put + delegates to .route + .post + delegates to .route + .route_param + calls #namespace with given params + nests requirements option under param name + does not modify options parameter + .scope + create a scope without affecting the URL + .prefix + sets a prefix for route + .routes + returns value received from #prepare_routes + when #routes was already called once + does not call prepare_routes again + .do_not_route_head! + sets do not route head option + .resources + is alias to #namespace + .group + is alias to #namespace + .segment + is alias to #namespace + .versions + returns last defined version + .delete + delegates to .route + .mount + mounts on a nested path + mounts multiple routes at once + .route + generates correct endpoint options + marks end of the route + resets validations + defines a new endpoint + does not duplicate identical endpoints + .options + delegates to .route + .resource + is alias to #namespace + .get + delegates to .route + .head + delegates to .route + .patch + delegates to .route + .do_not_route_options! + sets do not route options option + .namespace + creates a new namespace with given name and options + calls #joined_space_path on Namespace -Grape::Exceptions::InvalidFormatter - #message - contains the problem in the message +Grape::Validations + using a custom length validator + specified in the query string + under 140 characters + over 140 characters + using a custom request/param validator + does not fail when we send non-admin and admin=false fields only + fails when we send admin fields and we are not admin + 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 fields only + using a custom body-only validator + allows field in body + ignores field in query + Grape::Validations::Base + behaves like deprecated class + raises an ActiveSupport::DeprecationException + using a custom validator with message_key + fails with message -Grape::Exceptions::MissingMimeType - #message - contains the resolution in the message - contains the problem in the message +Grape::Endpoint + put + responds + get + responds without ext Grape::Util::ReverseStackableValues + #to_hash + returns a Hash representation #[]= - sets a value can handle array values pushes further values - #to_hash - returns a Hash representation + 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 - #keys - returns merged keys with parent - returns all keys #delete - does not delete parent values deletes a key + does not delete parent values #[] - returns an array of values parent values are not changed - returns parent value when no value is set combines parent and actual values (actual first) + returns an array of values + returns parent value when no value is set + #keys + returns merged keys with parent + returns all keys -Rack::Sendfile - when streaming non file content - not contains Sendfile headers - when calling sendfile - contains Sendfile headers - -Rack - correctly populates params from a Tempfile - when the app is mounted - finds the app on the namespace - -Grape::Endpoint - when route modifies param value - param default should not change - -Grape::Middleware::Auth::Base - authenticates if given valid creds - throws a 401 is wrong auth is given - -Grape::Exceptions::InvalidAcceptHeader - API with cascade=true, http_codes but without a rescue 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 show rescue handler processing - does not include the X-Cascade=pass header - 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, http_codes but without a rescue handler - that receives - 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 - an invalid version in the request - behaves like a not-cascaded request - does not include the X-Cascade=pass header - does not accept the request - 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=false and without a rescue handler - 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 include the X-Cascade=pass header - does not accept the request - 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 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 rescue_from :all 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=true and without a rescue 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 - -Grape::Endpoint - put - responds - get - responds without ext - -Grape::Exceptions::ValidationErrors - api - can return structured json with separate fields - #full_messages - when attributes is an array of symbols - returns an array with an error full message - with errors - returns an array with each errors full message - initialize - assigns headers through base class - message - is not repeated - is expected to include "FooBar is invalid" - is expected to eq 1 - -Grape::Middleware::Base - calls through to the app - has the app as an accessor - is able to access the response - callbacks on error - calls #after - header overwrite - overwrites header by after headers - callbacks - calls #before - calls #after - #context - allows access to response context - #response - when Rack::Response - returns the memoized Rack::Response instance - body - header - status - when Array - body - header - returns the memoized Rack::Response instance - status - 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 - header - is able to set a header - after callback - overwrites application response - -Grape::Validations::Validators::ExactlyOneOfValidator - #validate! - 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 exacly one param is present - does not return a validation error - when params are nested inside array - returns a validation error with full names of the params - when a subset of params are present - returns a validation error - when custom message is specified - returns a validation error - when all params are present - returns a validation error - mixed with other params - returns a validation error - when params are deeply nested - returns a validation error with full names of the params - when params are nested inside required hash - returns a validation error with full names of the params +Grape::Middleware::Error + + is possible to specify a different default status code + + is possible to return errors in json 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 specify a custom formatter + + does not trap regular error! codes + with rescue_all + StandardError exception + sets the message appropriately + defaults to a 500 status + Non-StandardError exception + does not trap errors other than StandardError + 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 return errors in xml format + + is possible to return errors in jsonapi format + with defaults + does not trap errors by default + + is possible to return hash errors in xml format + + is possible to return the backtrace and the original exception in txt format + + is possible to return hash errors in jsonapi format + + is possible to return hash errors in json format + + responds to custom Grape exceptions appropriately + + is possible to return the backtrace and the original exception in xml format -Grape::Exceptions::MissingOption +Grape::Exceptions::InvalidFormatter #message contains the problem in the message -Grape::Middleware::Versioner::AcceptVersionHeader - succeeds if :strict is not set - succeeds if :strict is set to false - 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 - fails with 406 Not Acceptable if version is not supported - is set - is set if format provided - when :strict is set - succeeds if proper header is set - fails with 406 Not Acceptable if header is not set - fails with 406 Not Acceptable if header is empty - -Grape::Validations::Validators::CoerceValidator - coerce - error on malformed input (Array) - error on malformed input - first-class JSON - works when declared optional - parses objects, hashes, and arrays - accepts Array[JSON] shorthand - doesn't make sense using coerce_with - with a custom validation message - errors on malformed input - on custom coercion rules - performs no additional coercion - respects :coerce_with - still validates type - using coerce_with - 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 with Array[String] type - must be supplied with :type or :coerce - uses parse where available - parses parameters even if type is valid - Integer type and coerce_with should - not coerce missing field - coerce nil value to integer - coerce integer as integer - Array type and coerce_with should - coerce array as array - coerce nil value to array - not coerce missing field - 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 - multiple types - fails when no coercion is possible - coerces to first possible type - may not be supplied together with a single type - custom coercion rules - still validates type - performs no additional coercion - respects :coerce_with - when params is Hashie::Mash - for primitive collections - allows singular form declaration - allows collections with multiple types - allows multiple collection types - for primitive collections - allows collections with multiple types - allows multiple collection types - allows singular form declaration - i18n - gives an english fallback error when default locale message is blank - i18n error on malformed input - converter - does not build a coercer multiple times - coerces - Nests integers - BigDecimal - Grape::API::Boolean - String - Integer - nil values - primitive types - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - respects the nil value - special types - respects the nil value - respects the nil value - respects the nil value - respects the nil value - variant-member-type collections - respects the nil value - respects the nil value - structures types - respects the nil value - respects the nil value - respects the nil value - File - collection - Rack::Multipart::UploadedFile - File - json - BigDecimal - Grape::API::Boolean - empty string - primitive types - is coerced to nil for type Numeric - is coerced to nil for type Time - is coerced to nil for type Date - is coerced to nil for type Grape::API::Boolean - is coerced to nil for type Symbol - is not coerced to nil for type String - is coerced to nil for type TrueClass - is coerced to nil for type FalseClass - is coerced to nil for type Integer - is coerced to nil for type DateTime - is coerced to nil for type Float - is coerced to nil for type BigDecimal - 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, [Integer, String]] - is coerced to nil for type [Integer, String] - structures types - is coerced to nil for type Array - is coerced to nil for type Set - Array - Array of type implementing parse - Array of Bools - Array of Integers - Set of type implementing parse - Array of a custom type - a custom type - coerces the given value - returning the InvalidValue instance when invalid - uses a custom message added to the invalid value - Set - Set of Integers - Set of Bools - -Grape::Parser - .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 - .builtin_parsers - returns an instance of Hash - includes json and xml parsers by default - .parser_for - returns parser correctly - calls .parsers - when parser is available - returns registered parser if available - when parser does not exist - returns nil - when parser is an instance of Symbol - returns an instance of Method - returns object which can be called - -Grape::Validations::Validators::MutualExclusionValidator - #validate! - when mutually exclusive 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 mutually exclusive params are nested inside required hash - 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 - when mutually exclusive params are deeply nested - returns a validation error with full names of the params - when no mutually exclusive params are present - does not return a validation error - when custom message is specified - returns a validation error - 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 - -Grape::API::Helpers - overriding subclass - given expected params - overrides helpers from a superclass - with lack of expected params - returns missing error - 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 - -StrictHashConfiguration - set nested configs - -Grape::API - with a global namespace function - works - Grape::API works for specified format doesn't work for format different than specified works for unspecified format -Grape::API::Helpers - defines parameters - -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 - #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 - #build - returns a rack builder instance - when @others are present - applies the middleware specs stored in @others - #insert_after - inserts a middleware after an anonymous class given by its superclass - inserts a middleware after another middleware class - raises an error on an invalid index - #merge_with - applies a collection of operations and middlewares - middleware spec with proc declaration exists - properly forwards spec arguments - #insert - inserts a middleware class at the integer index - #concat - adds non :use specs to @others - calls +merge_with+ with the :use specs +Grape::Exceptions::InvalidVersionerOption + #message + contains the problem in the message -Grape::Middleware::Globals - calls through to the app - environment - sets the grape.request environment - sets the grape.request.headers environment - sets the grape.request.params environment +Rack::Sendfile + when calling sendfile + contains Sendfile headers + when streaming non file content + not contains Sendfile headers -Grape::Exceptions::ValidationErrors - 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 - api without a rescue handler - with content_type text - can recover from failed body parsing - with content_type xml - 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 - api with rescue_from :all handler - with content_type xml - 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 - with no specific content_type - can recover from failed body parsing +Grape::Endpoint + #body + returns default + set + returns value + false + sets status to 204 + #route + returns route_info + #redirect + permanent + sets status to 301 + sets location header + default + sets location header + sets status to 302 + #sendfile + returns default + set + as object + raises an error that only a file path is supported + as file path + does not change the Content-Length header + does not change the Transfer-Encoding header + sends no deprecation warnings + returns value wrapped in StreamResponse + does not change the Cache-Control header + #stream + returns default + set + as a non-stream object + raises an error that the object must implement :each + 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 file path + sets Transfer-Encoding header to nil + returns file body wrapped in StreamResponse + sets Cache-Control header to no-cache + emits no deprecation warnings + sets Content-Length header to nil + does not change Cache-Control header + #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 file path + emits a warning that this method is deprecated +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 + 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 + #declared + is not available by default + #content_type + returns default + set + returns value + #cookies + returns an instance of Cookies + #error! + throws :error + thrown + sets status + default_error_status + sets status to default_error_status + #return_no_content + sets the status code and body + #present + multiple entities + instance + presents both dummy objects + with + entity + instance + presents dummy object + non mergeable entity + instance + fails + dummy + presents dummy object + #version + defaults to nil + returns env[api.version] + #status + defaults to 200 on GET + raises error if status is not a integer or symbol + defaults to 204 on DELETE + defaults to 200 on DELETE with a body present + defaults to 200 on GET + accepts symbol for status + defaults to 200 on GET + defaults to 201 on POST + returns status set + raises error if unknow symbol is passed + accepts unknown Integer status codes -Grape -/build/reproducible-path/ruby-grape-2.0.0/lib/grape/eager_load.rb:20: warning: possibly useless use of :: in void context - eager_load! - compile! +Grape::Endpoint + when route modifies param value + param default should not change Grape::Validations::Validators::AtLeastOneOfValidator #validate! - when restricted params are nested inside hash - when at least one of them is present - does not return a validation error + when restricted params are deeply nested 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 a subset of restricted params are present does not return 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 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 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 all restricted params are present does not return a validation error mixed with other params does not return a validation error + when exactly one of the restricted params is selected + 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 -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 - presents an error message - adds the status code if wanted - -Grape::Exceptions::InvalidVersionerOption - #message - contains the problem in the message - -Grape::Exceptions::UnknownValidator - #message - contains the problem in the message +Grape::DSL::Validations + .reset_validations! + does not reset documentation description + resets declared params + resets params + resets validations + .params + returns a ParamsScope + evaluates block Grape::API::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 + when an instance is mounted on the root + can call the instance endpoint with multiple moutes - responds the correct body at the first instance - responds the correct body at the second instance does not raise a FrozenError on second instance + responds the correct body at the second instance does not raise a FrozenError on first instance + responds the correct body at the first instance -Grape::DSL::Middleware - .insert_before - adds a middleware with the right operation - .middleware - returns the middleware stack - .use - adds a middleware with the right operation - .insert_after - adds a middleware with the right operation - .insert - adds a middleware with the right operation +Grape::Path + #path? + is true otherwise + is false when the path is nil + is false when the path starts with whitespace + is false when the path is the root path + #mount_path + is nil when no mount path setting exists + is nil when the mount path is nil + splits the mount path + #initialize + remembers the path + remembers the namespace + remebers the settings + #root_prefix + is nil when the mount path is nil + splits the mount path + is nil when no root prefix 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 + #path_with_suffix + combines the path and suffix + when using a specific format + might have a suffix with specified format + #path + uses the namespace after the mount path and root prefix + uses the raw path after the namespace + mount_path + is not included when it is nil + is included when it is not nil + root_prefix + is included after the mount path + is not included when it is nil + #suffix + 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 using a specific format + accepts specified format + when path versioning is used + includes a '/' + #uses_path_versioning? + is false when the version option is header + is false when the version setting is nil + is true when the version option is path -Grape::API::Helpers - defines parameters +Grape::API + with a global namespace function + works -Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder +Grape::Extensions::Hash::ParamBuilder in an api + symbolizes the params + symbolizes params keys #params - is a Hash - params are indifferent to symbol or string keys - responds to string keys - parses sub hash params + is Hash in an endpoint #params is of type Hash +Grape::Exceptions::UnknownValidator + #message + contains the problem in the message + +Grape::Exceptions::Base + #to_s + is expected to eq "a_message" + #compose_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 + 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 + #message + is expected to eq "a_message" + +Grape::DSL::Callbacks + .before + adds a block to "before" + .after + adds a block to "after" + .before_validation + adds a block to "before_validation" + .after_validation + adds a block to "after_validation" + +Grape::DSL::Helpers + .helpers + uses many provided modules + uses provided modules + adds a module with the given block + in child classes + is available + with an external file + sets Boolean as a Grape::API::Boolean + +Grape::Validations::Types + ::primitive? + recognizes Grape::API::Boolean as a primitive + recognizes Numeric as a primitive + recognizes BigDecimal as a primitive + identifies unknown types + recognizes Integer as a primitive + recognizes Symbol as a primitive + recognizes String as a primitive + recognizes Date as a primitive + recognizes Float as a primitive + recognizes DateTime as a primitive + recognizes Time as a primitive + 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 + ::custom? + returns true if the type responds to :parse with one argument + returns false if the type does not respond to :parse + returns false if the type's #parse method takes other than one argument + ::build_coercer + has internal cache variables + caches the result of the build_coercer method + ::special? + provides special handling for [JSON] + provides special handling for Rack::Multipart::UploadedFile + provides special handling for File + provides special handling for JSON + ::structure? + recognizes Set as a structure + recognizes Hash as a structure + recognizes Array as a structure + Grape::Validations::Validators::AllowBlankValidator invalid input - refuses missing - refuses only whitespaces - refuses nil refuses empty string - in a required group + refuses nil + refuses only whitespaces + refuses missing + valid input + accepts empty when boolean allow_blank + accepts empty input + accepts empty when date allow_blank + accepts empty input when allow_blank is false + allows missing optional strings + accepts value when time allow_blank + accepts valid 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 integer allow_blank + accepts empty when integer allow_blank + accepts empty when float allow_blank + in an optional group + as a required param + accepts a nested missing date value + accepts a missing group, even with a disallwed blank param + refuses a blank value in an existing group as an optional param - refuses a string value in an optional hash group + 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 - accepts a nested missing value - as a required param - refuses a string value in a required hash group - refuses a blank value in a required existing group custom validation message in an optional group - 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 as an optional param + refuses a blank existing value in an existing scope 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 - with invalid input - refuses empty string for an optional param - refuses only whitespaces - refuses nil - refuses empty string + as a required param + accepts a nested missing date value + accepts a missing group, even with a disallwed blank param + refuses a blank value in an existing group with valid input - accepts empty when date allow_blank - accepts valid input accepts empty input when allow_blank is false accepts empty when datetime allow_blank + accepts valid input accepts empty input - accepts empty when boolean allow_blank - accepts false when boolean allow_blank accepts empty when symbol allow_blank + accepts false when boolean allow_blank + accepts empty when date allow_blank + accepts empty 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 string value in a required hash group - refuses a blank value in a required existing group as an optional param - accepts a nested missing value refuses a blank existing value in an existing scope + accepts a nested missing value refuses a string value in an optional hash group - valid input - accepts empty when boolean allow_blank - accepts empty input - accepts empty input when allow_blank is false - accepts false when boolean allow_blank - accepts empty when datetime allow_blank - accepts empty when date allow_blank - allows missing optional strings - accepts valid input - accepts value when time allow_blank - accepts empty when symbol 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 an optional group + as a required param + refuses a blank value in a required existing group + refuses a string value in a required hash group + with invalid input + refuses empty string for an optional param + refuses only whitespaces + refuses empty string + refuses nil + in a required group 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 + refuses a blank value in a required existing group + refuses a string value in a required hash group as an optional param - accepts a missing group, even with a disallwed blank param - accepts a nested missing optional value + accepts a nested missing value + refuses a string value in an optional hash group refuses a blank existing value in an existing scope -Grape::Middleware::Auth::DSL - .http_basic - sets auth parameters - .http_digest - when realm is a hash - sets auth parameters - when realm is not hash - sets auth parameters - .auth - sets auth parameters - can be called multiple times +Grape::Validations::Types::PrimitiveCoercer + #call + Integer + accepts non-nil value + coerces an empty string to nil + Float + coerces an empty string to nil + the strict mode + BigDecimal + returns an error when the given value is not BigDecimal + returns a value as it is when the given value is BigDecimal + Boolean + returns an error when the given value is not Boolean + returns a value as it is when the given value is Boolean + DateTime + coerces an empty string to nil + a type unknown in Dry-types + raises error on init + String + does not coerce an empty string to nil + coerces to String + Symbol + coerces an empty string to nil + Boolean + coerces '0' to false + coerces an empty string to nil + returns an error when the given value cannot be coerced + coerces 'true' to true + coerces 'true' to true + coerces '1' to true + coerces 'false' to false + coerces 'false' to false + Numeric + accepts a non-nil value + coerces an empty string to nil + BigDecimal + coerces to BigDecimal + coerces an empty string to nil + Time + coerces an empty string to nil -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::Validations::SingleAttributeIterator + #each + when params is an array + yields every single attribute from the list for each of the array elements + empty values + marks params with empty values + when missing optional value + does not yield skipped values + when params is a hash + yields params and every single attribute from the list + +Grape::DSL::Parameters + #optional + adds an optional parameter + #at_least_one_of + adds an at least one of parameter validation + #mutually_exclusive + adds an mutally exclusive parameter validation + #includes + is alias to #use + #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 + #use_scope + is alias to #use + #with + creates a scope with group attributes + #exactly_one_of + adds an exactly of one parameter validation + #requires + adds a required parameter + #group + is alias to #requires + #all_or_none_of + adds an all or none of parameter validation + #use + raises error when non-existent named param is called + calls processes associated with named params Grape::Middleware::Versioner recognizes :accept_version_header @@ -4284,929 +4466,625 @@ recognizes :header recognizes :param -Grape::Exceptions::InvalidResponse - #message - contains the problem in the message - -Grape::Exceptions::UnsupportedGroupType - #message - is expected to include "group type must be Array, Hash, JSON or Array[JSON]" - Grape::Exceptions::UnsupportedGroupTypeError - behaves like deprecated class - raises an ActiveSupport::DeprecationException - -Grape::Middleware::Versioner::Header - succeeds if :strict is not set - succeeds if :strict is set to false - succeeds if :strict is set to false and given an invalid header - api.vendor - is set - fails with 406 Not Acceptable if vendor is invalid - is set if format provided - when version is set - is set - is set if format provided - fails with 406 Not Acceptable if vendor is invalid - api.type and api.subtype - sets preferred type - sets preferred type and subtype - sets type and subtype to first choice of content type if no preference given - when :strict is set - 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 if format provided - fails with 406 Not Acceptable if version is invalid - is set - when multiple versions are specified - succeeds with v1 - fails with another version - succeeds with v2 - when :strict and cascade: false - fails with 406 Not Acceptable if header is empty - fails with 406 Not Acceptable if header is not set - fails with 406 Not Acceptable if header contains a single invalid accept - fails with 406 Not Acceptable if header is application/xml - succeeds if proper header is set - with missing vendor option - fails - 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.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 set - is nil if not provided +Grape::Endpoint + get + json format + no format + invalid format -Grape::DSL::Headers - when no headers are set - #header +Grape::Parser + .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 + calls .parsers + returns parser correctly + 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 - when headers are set - #header - get - returns a specifc value - returns all set headers - delete - deletes a header key-value pair - set - returns value - -Grape - .config - is expected to eq {:param_builder=>Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder} + .builtin_parsers + returns an instance of Hash + includes json and xml parsers by default -Grape::Middleware::Auth::Strategies - Basic Auth - authenticates if given valid creds - throws a 401 if no auth is given - throws a 401 is wrong auth is given +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::ParamsScope includes the nested parameter within #declared(params) - includes deeply nested parameters within #declared(params) includes level 2 nested parameters outside the given within #declared(params) - returns a sensible error message within a nested context raises an error if the dependent parameter was never specified + includes deeply nested parameters within #declared(params) + returns a sensible error message within a nested context when validations are dependent on a parameter within an array param within #declared(params).to_json applies the constraint within each value - 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 - array without coerce type explicitly given - raises exception when values are of different type - fails to call API without Array type - sets the type based on first element - raises exception when range values have different endpoint types with range values + when left range endpoint isn't #kind_of? the type + raises exception 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 + and is a subset of allowed values + does not raise an 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 left range endpoint isn't #kind_of? the type - raises exception - failing fast - when fail_fast is defined it stops the validation - for a single param - of other params - when fail_fast is not defined - does not stop validation - when validations are dependent on a parameter within an array param - passes none Hash params + 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 + when using custom types + coerces the parameter via the type's parse method param renaming + is expected to eq "foo is empty" + renaming can be defined after default is expected to eq "{\"baz\":{\"qux\":\"any\"}}" is expected to eq "any-any2" - is expected to eq "foo is empty" renaming can be defined before default - is expected to eq "-there we go" is expected to eq 200 - renaming can be defined after default + is expected to eq "-there we go" + 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 + coercing values validation with proc + allows the proc to pass validation without checking in value + allows the proc to pass validation without checking +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 when validations are dependent on a parameter with specific value - (case 14) - applies the validation when base param has the specific value + (case 11) 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 7) + (case 14) 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) - skips validation when base param is missing - (case 1) - includes the parameter within #declared(params) - skips validation when base param is missing + (case 9) applies the validation when base param has the specific value skips validation when base param does not have a specified value - (case 0) includes the parameter within #declared(params) - skips validation when base param does not have a specified value - skips validation when base param is missing - applies the validation when base param has the specific value - (case 12) + (case 2) 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 13) - 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 8) - 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) + (case 15) 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 11) + (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 0) + skips validation when base param does not have a specified value includes the parameter within #declared(params) - (case 6) applies the validation when base param has the specific value - includes the parameter within #declared(params) + skips validation when base param is missing + (case 5) + 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 6) skips validation when base param is missing - (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 + (case 1) skips validation when base param is missing skips validation when base param does not have a specified value - (case 10) + includes the parameter within #declared(params) applies the validation when base param has the specific value + (case 8) skips validation when base param does not have a specified value includes the parameter within #declared(params) - (case 9) applies the validation when base param has the specific value - skips validation when base param does not have a specified value + (case 7) includes the parameter within #declared(params) - (case 3) + 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 12) + 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) + skips validation when base param does not have a specified value skips validation when base param is missing - (case 15) 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 5) + (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 - applies the validation when base param has the specific value - when using custom types - coerces the parameter via the type's parse method + array without coerce type explicitly given + fails to call API without Array type + sets the type based on first element + raises exception when values are of different type + raises exception when range values have different endpoint types + failing fast + when fail_fast is defined it stops the validation + for a single param + of other params + when fail_fast is not defined + does not stop validation + when validations are dependent on a parameter within an array param + passes none Hash params + parameters in group + allows Hash as type + errors with an unsupported type + errors when no type is provided + handles missing optional Array type + allows Array as type 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 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 date returns a successful response when invalid date provided - returns a validation error responds with HTTP error + returns a validation error with validations when parameter has the same validator as a group - returns a successful response prioritizes parameter validation over group validation - when data is invalid - applies group validations for every parameter - returns a validation error - 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 + applies group validations for every parameter returns a validation error - responds with HTTP error - 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 - parameters in group - errors with an unsupported type - allows Hash as type - handles missing optional Array type - allows Array as type - errors when no type is provided when validations are dependent on a parameter + allows nested dependent parameters + raises an error if the dependent parameter is the renamed one + raises an error if the dependent parameter was never specified applies only the appropriate validation - includes level 2 nested parameters outside the given within #declared(params) - allows renaming of dependent on parameter - applies the validations only if the parameter is present - applies the validations of multiple parameters - detect unmet nested dependency + does not raise if the dependent parameter is not the renamed one does not raise an error if when using nested given + allows renaming of dependent parameters + includes level 2 nested parameters outside the given within #declared(params) does not raise an error if the dependent parameter is a Hash includes the parameter within #declared(params) - does not raise if the dependent parameter is not the renamed one - allows renaming of dependent parameters - returns a sensible error message within a nested context - allows nested dependent parameters includes the nested parameter within #declared(params) - raises an error if the dependent parameter was never specified - raises an error if the dependent parameter is the renamed one does not validate nested requires when given is false + returns a sensible error message within a nested context + applies the validations only if the parameter is present + applies the validations of multiple parameters + detect unmet nested dependency + allows renaming of dependent on parameter when the dependent parameter is not present #declared(params) - lateral parameter within an array param - evaluate_given_true - evaluate_given_false nested given parameter within a nested given parameter within an array param + evaluate_given_false evaluate_given_true + lateral parameter evaluate_given_false - nested given parameter evaluate_given_true + nested given parameter evaluate_given_false + evaluate_given_true nested given parameter within an array param + evaluate_given_true + evaluate_given_false + lateral parameter within an array param evaluate_given_false evaluate_given_true - lateral parameter + lateral hash parameter evaluate_given_false evaluate_given_true lateral parameter within lateral hash parameter - evaluate_given_true - evaluate_given_false - lateral hash parameter evaluate_given_false evaluate_given_true - 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 - -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 a namespace param with dots - routes to namespace and path params with dots, with overridden requirements - -Validator with instance variables - passes validation every time - -Grape::DSL::Logger - .logger - sets a logger - returns a logger - -Grape::Middleware::Formatter - accept header detection - ignores invalid quality rankings - detects from the Accept header - handles quality rankings mixed with nothing - parses headers with other attributes - uses quality rankings to determine formats - parses headers with vendor and api version - handles quality rankings that have a default 1.0 value - ensures that a quality of 0 is less preferred than any other content type - parses headers with symbols as hash keys - 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 - error handling -caught error of type StandardError in after callback inside Grape::Middleware::Formatter : StandardError - does not rescue other exceptions - rescues formatter-specific exceptions - inheritable formatters - returns response by invalid formatter - input - ignores multipart/mixed - ignores application/x-www-form-urlencoded - ignores multipart/related - parses the body from an xml POST and copies values into rack.request.from_hash - ignores multipart/related - parses the chunked body from PUT and copies values into rack.request.from_hash - parses the body from an xml DELETE and copies values into rack.request.from_hash - ignores multipart/mixed - ignores multipart/related - ignores application/x-www-form-urlencoded - ignores multipart/mixed - rewinds IO - ignores multipart/mixed - ignores multipart/form-data - parses the chunked body from DELETE and copies values into rack.request.from_hash - ignores multipart/form-data - ignores application/x-www-form-urlencoded - ignores multipart/form-data - rewinds IO - parses the chunked body from PATCH and copies values into rack.request.from_hash - parses the body from an xml PATCH and copies values into rack.request.from_hash - parses the chunked body from POST and copies values into rack.request.from_hash - ignores application/x-www-form-urlencoded - ignores multipart/related - rewinds IO - ignores multipart/form-data - rewinds IO - parses the body from an xml PUT and copies values into rack.request.from_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 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 - 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 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 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 DELETE and copies values into rack.request.form_hash - when body is not nil or empty - when Content-Type is supported - parses the body from POST and copies values into rack.request.form_hash - when Content-Type is not supported - returns a 415 HTTP error status - when body is nil - 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 - parses the body from PUT 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 - application/json; charset=utf-8 - parses the body from DELETE 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 PATCH 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 - application/json - parses the body from DELETE and copies values into rack.request.form_hash - when body is nil - does not read and parse the body - detection - uses the json extension if one is provided - uses the format parameter if one is provided - uses the default format if none is provided - uses the requested format if provided in headers - uses the file extension format if provided before headers - uses the xml extension if one is provided - send file - returns a file response - 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 - no content responses - does not modify a 119 response - does not modify a 107 response - does not modify a 168 response - does not modify a 145 response - does not modify a 139 response - does not modify a 188 response - does not modify a 117 response - does not modify a 150 response - does not modify a 111 response - does not modify a 175 response - does not modify a 185 response - does not modify a 112 response - does not modify a 162 response - does not modify a 179 response - does not modify a 108 response - does not modify a 130 response - does not modify a 101 response - does not modify a 197 response - does not modify a 135 response - does not modify a 181 response - does not modify a 144 response - does not modify a 169 response - does not modify a 157 response - does not modify a 116 response - does not modify a 143 response - does not modify a 171 response - does not modify a 163 response - does not modify a 172 response - does not modify a 191 response - does not modify a 153 response - does not modify a 123 response - does not modify a 152 response - does not modify a 173 response - does not modify a 166 response - does not modify a 134 response - does not modify a 190 response - does not modify a 194 response - does not modify a 114 response - does not modify a 165 response - does not modify a 146 response - does not modify a 106 response - does not modify a 159 response - does not modify a 113 response - does not modify a 199 response - does not modify a 137 response - does not modify a 120 response - does not modify a 129 response - does not modify a 195 response - does not modify a 193 response - does not modify a 122 response - does not modify a 100 response - does not modify a 192 response - does not modify a 128 response - does not modify a 174 response - does not modify a 167 response - does not modify a 149 response - does not modify a 124 response - does not modify a 147 response - does not modify a 204 response - does not modify a 118 response - does not modify a 132 response - does not modify a 115 response - does not modify a 177 response - does not modify a 186 response - does not modify a 138 response - does not modify a 133 response - does not modify a 182 response - does not modify a 104 response - does not modify a 126 response - does not modify a 156 response - does not modify a 164 response - does not modify a 155 response - does not modify a 178 response - does not modify a 121 response - does not modify a 154 response - does not modify a 105 response - does not modify a 136 response - does not modify a 170 response - does not modify a 158 response - does not modify a 151 response - does not modify a 141 response - does not modify a 102 response - does not modify a 304 response - does not modify a 161 response - does not modify a 103 response - does not modify a 110 response - does not modify a 176 response - does not modify a 184 response - does not modify a 148 response - does not modify a 196 response - does not modify a 127 response - does not modify a 109 response - does not modify a 183 response - does not modify a 160 response - does not modify a 187 response - does not modify a 125 response - does not modify a 198 response - does not modify a 131 response - does not modify a 140 response - does not modify a 180 response - does not modify a 142 response - does not modify a 189 response - content-type - is set for xml - is set for vendored with registered type - is set for json - is set for custom - is set to closest generic for custom vendored/versioned without registered type - is set for txt - -Grape::DSL::Validations - .reset_validations! - resets params - resets validations - does not reset documentation description - resets declared params - .params - evaluates block - returns a ParamsScope - -Grape::Validations::Types - ::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 JSON - is expected to eq Grape::Validations::Types::Json - 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 - ::structure? - recognizes Set as a structure - recognizes Array as a structure - recognizes Hash as a structure - ::special? - provides special handling for [JSON] - provides special handling for Rack::Multipart::UploadedFile - provides special handling for File - provides special handling for JSON - ::primitive? - recognizes DateTime as a primitive - recognizes Date as a primitive - recognizes Grape::API::Boolean as a primitive - identifies unknown types - recognizes Float as a primitive - recognizes Numeric as a primitive - recognizes BigDecimal as a primitive - recognizes String as a primitive - recognizes Integer as a primitive - recognizes Time as a primitive - recognizes Symbol as a primitive - ::build_coercer - has internal cache variables - caches the result of the build_coercer method -Grape::Validations - using a custom request/param validator - does not fail when we send non-admin fields only - fails when we send admin fields and we are not admin - does not fail when we send non-admin and admin=false fields only - fail when non-admin user sets an admin field - does not fail when we send admin fields and we are admin - Grape::Validations::Base - behaves like deprecated class - raises an ActiveSupport::DeprecationException - using a custom length validator - over 140 characters - specified in the query string - under 140 characters - using a custom body-only validator - ignores field in query - allows field in body - using a custom validator with message_key - fails with message - -Grape::Validations::Validators::DefaultValidator - set default values for optional params - set default values for optional params and allow to use required fields in the same time - lets you leave required values nested inside an optional blank - does not allows faulty optional arrays - sets default values for grouped arrays - sets lambda based defaults at the time of call - set default values for missing params in the request - set default value for optional param - allows optional arrays with optional params - allows optional arrays to be omitted - 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 without default value includes optional param with default value - returns nil for optional hash if param is not provided - does not fail even if invalid params is passed to default validator - optional hash with default value includes optional param with default value - sets default value for optional hash if param is not provided - sets own default value for inner param if parent param is provided - sets default value from parent defaults for inner param if parent param is not provided - array with default values and given conditions - applies the default values only if the conditions are met - optional with nil as 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 - 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 +Grape::Middleware::Base + calls through to the app + has the app as an accessor + is able to access the response + header overwrite + overwrites header by after headers + #context + allows access to response context + header + is able to set a header + #response + when Array + returns the memoized Rack::Response instance + status + header + body + when Rack::Response + header + status + returns the memoized Rack::Response instance + body + callbacks on error + calls #after + callbacks + calls #after + calls #before + after callback with errors + does not overwrite the application response + with patched warnings + does show a warning + after callback + overwrites application response + options + persists options passed at initialization + defaults + overrides default options when provided + persists the default options -Grape::DSL::Helpers - .helpers - uses many provided modules - adds a module with the given block - uses provided modules - in child classes - is available - with an external file - sets Boolean as a Grape::API::Boolean +Grape::Exceptions::UnknownOptions + #message + contains the problem in the message -Grape::DSL::RequestResponse - .default_error_status - sets a default error status - .format - sets a new format - .content_types - returns all content types - .default_format - sets the default format - returns the format without paramter - .rescue_from - list of exceptions is passed - rescues only base handlers if rescue_subclasses: false option is passed - sets a rescue handler declared through :with option for each key in hash - sets hash of exceptions as rescue handlers - sets given proc as rescue handler for each key in hash - sets given block as rescue handler for each key in hash - :all - sets rescue all to true - abort if :with option value is not Symbol, String or Proc - abort if both :with option and block are passed - sets given proc as rescue handler - sets a rescue handler declared through :with option - sets given block as rescue handler - :grape_exceptions - sets given proc as rescue handler - sets rescue all to true - sets given block as rescue handler - sets a rescue handler declared through :with option - .represent - sets a presenter for a class - .default_error_formatter - sets a new error formatter - .error_formatter - understands syntactic sugar - sets a error_formatter - .formatter - sets the formatter for a content type - .content_type - sets a content type for a format - .parser - sets a parser for a content type +Grape::Middleware::Versioner::Path + sets the API version based on the first path + provides a nil version if no path is given + does not cut the version out of the path + 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 + ignores the version if it fails to match + sets the version if it matches + with specified versions as [:v1, :v2] + throws an error if a non-allowed version is specified + allows versions that have been specified + with mount path + 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 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 -Grape::API - execute first request in reasonable time +Grape::Validations::Validators::RegexpValidator + accepts valid input + accepts nil + custom validation message + accepts nil + accepts valid input + regexp with array + accepts valid items + refuses empty items + accepts nil instead of array + refuses nil items + refuses inapppopriate items + with invalid input + refuses empty + refuses inapppopriate + regexp with array + accepts nil instead of array + refuses empty items + refuses inapppopriate items + accepts valid items + refuses nil items + invalid input + refuses inapppopriate + refuses empty + nested regexp with array + refuses inapppopriate Grape::Endpoint - #declared; mixed nesting - can access parent route_param - #declared; with multiple route_param - return :filter and :id parameters in declared for second enpoint inside route_param - return only :id without :artist_id - return only :artist_id without :id - return :compositor_id for mounter in route_param - parameter renaming - with a renamed root parameter - 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 parameters - generates the correct parameter names for documentation - validates the renamed parameter correctly (original name) - maps the renamed parameter correctly (original name) - ignores the renamed parameter (as name) - with a renamed hash with nested renamed parameter - ignores the renamed parameter (as name, 2) - generates the correct parameter names for documentation - ignores the renamed parameter (as name, 3) - maps the renamed parameter correctly (original name) - ignores the renamed parameter (as name, 1) - validates the renamed parameter correctly (original name) - with a deeply nested parameter structure - maps no parameters when none are given - generates the correct parameter names for documentation - does not modify the request params - maps the renamed parameter correctly #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 + with include_parent_namespaces: true + returns declared parameters from every parent namespace #declared - shows nil for multiple allowed types if include_missing is true + includes attributes with value that evaluates to false + does not include missing attributes when there are nested hashes builds nested params when given array + stringifies if that option is passed + builds nested params + shows nil for nested params if include_missing is true does not work in a before filter - filters out any additional params that are given + does not include missing attributes if that option is passed + does not include renamed missing attributes if that option is passed + has as many keys as there are declared params includes attributes with value that evaluates to nil builds arrays correctly - builds nested params - shows nil for nested params if include_missing is true has a optional param with default value all the time - does not include missing attributes if that option is passed + filters out any additional params that are given + shows nil for multiple allowed types if include_missing is true includes missing attributes with defaults when there are nested hashes - does not include missing attributes when there are nested hashes - has as many keys as there are declared params - includes attributes with value that evaluates to false - stringifies if that option is passed - does not include renamed missing attributes if that option is passed when params are not built with default class -W, [2024-12-18T08:56:22.944520 #44212] 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-12-18T08:56:22.945165 #44212] 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 returns an object that corresponds with the params class - hash + returns an object that corresponds with the params class - hash with indifferent access +W, [2026-01-21T17:20:30.389664 #4132] 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, [2026-01-21T17:20:30.390099 #4132] 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 + when the param is missing and include_missing=false + sets nested objects to be nil when the param is missing and include_missing=true - includes all declared children when type=Hash sets objects with type=Set to be a set sets objects with type=Array to be an array sets objects with type=Hash to be a hash - when the param is missing and include_missing=false - sets nested objects to be nil + includes all declared children when type=Hash + parameter renaming + with a renamed hash with nested renamed parameter + generates the correct parameter names for documentation + ignores the renamed parameter (as name, 2) + validates the renamed parameter correctly (original name) + ignores the renamed parameter (as name, 3) + ignores the renamed parameter (as name, 1) + maps the renamed parameter correctly (original name) + with a renamed hash with nested parameters + generates the correct parameter names for documentation + ignores the renamed parameter (as name) + validates the renamed parameter correctly (original name) + maps the renamed parameter correctly (original name) + with a renamed root parameter + validates the renamed parameter correctly (original name) + maps the renamed parameter correctly (original name) + ignores the renamed parameter (as name) + generates the correct parameter names for documentation + with a deeply nested parameter structure + does not modify the request params + generates the correct parameter names for documentation + maps the renamed parameter correctly + maps no parameters when none are given + #declared; mixed nesting + can access parent route_param #declared; from a nested mounted endpoint can access parent attributes + #declared; with multiple route_param + return :filter and :id parameters in declared for second enpoint inside route_param + return :compositor_id for mounter in route_param + return only :id without :artist_id + return only :artist_id without :id + +Grape::Validations::Validators::ExactlyOneOfValidator + #validate! + when params are nested inside array + returns a validation error with full names of the params + when custom message is specified + returns a validation error + when params are deeply nested + returns a validation error with full names of the params + when a subset of params are present + returns a validation error + when all params are present + returns a validation error + mixed with other params + returns a validation error + when exacly one param is present + does not return a validation error + when params are nested inside required hash + returns a validation error with full names of the params + when none of the params are present + returns 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 + +Grape::API::Instance + boolean constant + sets Boolean as a type + Params endpoint type + params type is a boolean + +Grape::Middleware::Auth::Strategies + Basic Auth + authenticates if given valid creds + throws a 401 is wrong auth is given + throws a 401 if no auth is given Grape::API - .recognize_path - returns nil if given path does not match with registered routes - fetches endpoint by given path + execute first request in reasonable time -Grape::Util::InheritableSetting - #api_class - is specific to the class - #global - sets a global value - sets the global inherited values - handles different parents - overrides global values - #namespace_reverse_stackable - works with reverse stackable values - #inherit_from - notifies clones - #route - works with route values - sets a value until the next route - #namespace_inheritable - works with inheritable values - handles different parents - #point_in_time_copy - decouples namespace values - decouples namespace inheritable values - decouples namespace reverse stackable values - decouples route values - adds itself to original as clone - decouples namespace stackable values - resets point_in_time_copies - #namespace_stackable - works with stackable values - #to_hash - return all settings as a hash - #api_class - is specific to the class - #namespace - uses new values when a new namespace starts - sets a value until the end of a namespace +Grape::Middleware::Versioner::AcceptVersionHeader + succeeds if :strict is not set + succeeds if :strict is set to false + 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 + 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::Endpoint - get - responds - put - responds +Grape::Middleware::Versioner::Header + succeeds if :strict is set to false and given an invalid header + succeeds if :strict is set to false + succeeds if :strict is not set + when multiple versions are specified + succeeds with v2 + fails with another version + succeeds with v1 + when :strict and cascade: false + fails with 406 Not Acceptable if header is empty + fails with 406 Not Acceptable if header contains a single invalid accept + fails with 406 Not Acceptable if header is not set + succeeds if proper header is set + fails with 406 Not Acceptable if header is application/xml + 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.version + is set + fails with 406 Not Acceptable if version is invalid + is set if format provided + api.vendor + is set if format provided + fails with 406 Not Acceptable if vendor is invalid + is set + when version is set + is set if format provided + fails with 406 Not Acceptable if vendor is invalid + is set + api.format + is nil if not provided + is set + 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.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 + with missing vendor option + fails + 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 + +A named API + can access the name of the API + +Grape::Exceptions::MissingOption + #message + contains the problem in the message Grape::API::Helpers patch - default private + default public default default private public +Grape::Endpoint + post + 405 + +Grape::DSL::Desc + .desc + sets a description + can be set with options and a block + can be set with a block + +Grape::DSL::Middleware + .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 + .insert_after + adds a middleware with the right operation + .middleware + returns the middleware stack + +Grape::Extensions::Hashie::Mash::ParamBuilder + in an api + is indifferent to key or symbol access + #params + is Hashie::Mash + in a nested namespace api + is Hashie::Mash + in an endpoint + #params + is of type Hashie::Mash + +Grape::Endpoint + put + responds + get + responds + Grape::Validations::Validators::ValuesValidator - does not validate updated values without proc + validates against values in an endless range validates against values in a proc -Error 'comparison of String with 0 failed' raised while validating attribute 'number' - does not allow non-numeric string value for int value using lambda - raises IncompatibleOptionValues when type is incompatible with values array + does not allow an invalid value for a parameter 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 numeric string for int value using lambda - rejects all values if values is an empty array - allows values to be a kind of the coerced type not just an instance of it + allows value using lambda allows a blank value when the allow_blank option is true + does not allow an invalid value for a parameter using an endless range allows a valid default value - raises IncompatibleOptionValues on an invalid default value from proc - raises IncompatibleOptionValues when values contains a value that is not a kind of the type - validates against an empty array in a proc + raises IncompatibleOptionValues when type is incompatible with values array + does not validate updated values without proc + raises IncompatibleOptionValues on an invalid default value validates default value from proc + raises IncompatibleOptionValues when values contains a value that is not a kind of the type validates default value from proc against values in a proc + allows values to be a kind of the coerced type in an array + raises IncompatibleOptionValues on an invalid default value from proc + allows values to be a kind of the coerced type not just an instance of it + allows a proc for values + does not allow invalid value using lambda + 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 +Error 'comparison of String with 0 failed' raised while validating attribute 'number' + does not allow non-numeric string value for int value using lambda 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 - raises IncompatibleOptionValues when except contains a value that is not a kind of the type - validates against values in an endless range - allows 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 - does not allow an invalid value for a parameter - does not allow an invalid value for a parameter using lambda - allows a valid default value - allows values to be a kind of the coerced type in an array - does not allow invalid value using lambda - raises IncompatibleOptionValues on an invalid default value allows a valid value for a parameter - does not allow an invalid value for a parameter using an endless range - allows a proc for values - exclude with a standard custom validation message + validates against an empty array in a proc + allows a valid default 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) - 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 -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 - 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 - accepts a valid value - rejects an invalid value nil value for a parameter - does not allow for root params scope accepts for an optional param with a list of values allows for a required param in child scope + does not allow for root params scope + with a range of values + allows a single value inside of the range + rejects an array of values if any of them are outside the range + rejects a single value outside the range + allows an array of values inside of the range + boolean values + allows a value from the list + rejects a value which is not in 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) rejects values that matches except @@ -5214,66 +5092,223 @@ 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) allows any other value outside excepts when type is included - exclusive 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) - rejects an array of values if any of them matches except + does not allow an invalid value for a parameter + 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 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) + 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 +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 + 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) 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 when type is included + 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 - 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 - 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 - 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 - boolean values - allows a value from the list - rejects a value which is not in the list - with a lambda values - chooses default - only evaluates values dynamically with each request + allows any other value outside excepts when type is included 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 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) + with a lambda values + only evaluates values dynamically with each request + chooses default + with a custom validation message + allows a valid value for a parameter does not allow an invalid value for a parameter - 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) - rejects outside except and outside 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) - 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) - allows value, but not in except + does not allow an invalid value for a parameter using lambda + validates against values in a proc + 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) + accepts multiple valid values +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) + 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) + 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) + uses supplied message + 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 -Grape::Exceptions::Base - #message - is expected to eq "a_message" - #compose_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 - 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 - #to_s - is expected to eq "a_message" +Grape::Endpoint + get + responds with ext + responds without ext + put + responds + +Grape::Util::InheritableValues + #clone + complex (i.e. not primitive) data types (ex. entity classes, please see bug #891) + copies values; does not duplicate them + #delete + deletes a key + does not delete parent values + #to_hash + returns a Hash representation + #[] + returns a value + parent values are not changed + returns parent value when no value is set + overwrites parent value with the current one + #[]= + sets a value + +Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder + in an endpoint + #params + is of type Hash + in an api + #params + params are indifferent to symbol or string keys + parses sub hash params + is a Hash + responds to string keys + +Grape::API::Helpers + non overriding 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 + example subclass + given expected params + inherits helpers from a superclass + with lack of expected params + returns missing error + +Grape::Validations::Validators::ExceptValuesValidator + 8: opt_except_lambda_default - invalid-type1 + 0: req_except - invalid-type3 + 2: req_except_custom_message - invalid-type1 + 7: opt_except_default - invalid-type3 + 11: opt_except_array_type_coerce_default - [10] + 5: req_except_lambda - invalid-type1 + 6: req_except_lambda_custom_message - invalid-type4 + 10: opt_except_type_coerce_default - 3 + 10: opt_except_type_coerce_default - 10 + 4: req_except_empty - invalid-type1 + 0: req_except - invalid-type1 + 11: opt_except_array_type_coerce_default - + 11: opt_except_array_type_coerce_default - [3] + 9: req_except_type_coerce - 11 + 2: req_except_custom_message - invalid-type3 + 9: req_except_type_coerce - 11 + 9: req_except_type_coerce - 3 + 12: req_except_range - 13 + 11: opt_except_array_type_coerce_default - invalid-type1 + 1: req_except_hash - valid-type + 10: opt_except_type_coerce_default - + 11: opt_except_array_type_coerce_default - 10 + raises IncompatibleOptionValues when a default array has excluded values + 3: req_except_no_value - invalid-type1 + 2: req_except_custom_message - valid-type + 8: opt_except_lambda_default - valid-type + 5: req_except_lambda - invalid-type4 + 1: req_except_hash - invalid-type3 + raises IncompatibleOptionValues when type is incompatible with values array + 7: opt_except_default - valid-type + 6: req_except_lambda_custom_message - invalid-type1 + raises IncompatibleOptionValues on a default value in exclude + 5: req_except_lambda - valid-type + 9: req_except_type_coerce - 3 + 6: req_except_lambda_custom_message - valid-type + 1: req_except_hash - invalid-type1 + 8: opt_except_lambda_default - invalid-type3 + 0: req_except - valid-type + 11: opt_except_array_type_coerce_default - ["3"] + 12: req_except_range - 11 + 7: opt_except_default - invalid-type1 + 10: opt_except_type_coerce_default - 3 + 8: opt_except_lambda_default - + 10: opt_except_type_coerce_default - invalid-type1 + 7: opt_except_default - + 9: req_except_type_coerce - invalid-type1 + +Grape::Middleware::Error + sets the error message appropriately + defaults to a 500 status + sets the status code appropriately + sets the status code based on the rack util status code symbol + has a default message + with http code + presents an error message + adds the status code if wanted + +Grape::Validations::Validators::AllOrNoneOfValidator + #validate! + 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 + 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 restricted 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 custom message is specified + returns a validation error + +Grape::Validations::Types::ArrayCoercer + #call + an array of primitives + coerces elements in the array + an array of sets + coerces elements in the nested set + an array of arrays + coerces elements in the nested array + +Grape::Middleware::Auth::Base + authenticates if given valid creds + throws a 401 is wrong auth is given + +Grape::Presenters::Presenter + represent + represent object + present + multiple presenter + instance + presents both dummy presenter + instance + presents dummy hash + +Grape::Middleware::Auth::DSL + .http_basic + sets auth parameters + .http_digest + when realm is not hash + sets auth parameters + when realm is a hash + sets auth parameters + .auth + sets auth parameters + can be called multiple times Pending: (Failures listed here are expected and do not affect your suite's status) @@ -5281,10 +5316,10 @@ # Temporarily skipped with xit # ./spec/integration/multi_json/json_spec.rb:4 -Finished in 9.28 seconds (files took 2.44 seconds to load) +Finished in 4.92 seconds (files took 1.04 seconds to load) 2171 examples, 0 failures, 1 pending -Randomized with seed 54938 +Randomized with seed 42951 ┌──────────────────────────────────────────────────────────────────────────────┐ @@ -5315,12 +5350,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/29668/tmp/hooks/B01_cleanup starting +I: user script /srv/workspace/pbuilder/29668/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/33063 and its subdirectories -I: Current time: Wed Dec 18 08:56:28 -12 2024 -I: pbuilder-time-stamp: 1734555388 +I: removing directory /srv/workspace/pbuilder/29668 and its subdirectories +I: Current time: Wed Jan 21 17:20:35 +14 2026 +I: pbuilder-time-stamp: 1768965635