grape-0.16.2/0000755000004100000410000000000012706307017012731 5ustar www-datawww-datagrape-0.16.2/Rakefile0000644000004100000410000000310012706307016014367 0ustar www-datawww-datarequire 'rubygems' require 'bundler' Bundler.setup :default, :test, :development Bundler::GemHelper.install_tasks require 'rspec/core/rake_task' RSpec::Core::RakeTask.new(:spec) do |spec| spec.pattern = 'spec/**/*_spec.rb' end RSpec::Core::RakeTask.new(:rcov) do |spec| spec.pattern = 'spec/**/*_spec.rb' spec.rcov = true end task :spec require 'rainbow/ext/string' unless String.respond_to?(:color) require 'rubocop/rake_task' RuboCop::RakeTask.new task default: [:rubocop, :spec] require 'yard' DOC_FILES = ['lib/**/*.rb', 'README.md'] YARD::Rake::YardocTask.new(:doc) do |t| t.files = DOC_FILES end namespace :doc do YARD::Rake::YardocTask.new(:pages) do |t| t.files = DOC_FILES t.options = ['-o', '../grape.doc/docs'] end namespace :pages do desc 'Check out gh-pages.' task :checkout do dir = File.dirname(__FILE__) + '/../grape.doc' unless Dir.exist?(dir) Dir.mkdir(dir) Dir.chdir(dir) do system('git init') system('git remote add origin git@github.com:ruby-grape/grape.git') system('git pull') system('git checkout gh-pages') end end end desc 'Generate and publish YARD docs to GitHub pages.' task publish: ['doc:pages:checkout', 'doc:pages'] do Dir.chdir(File.dirname(__FILE__) + '/../grape.doc') do system('git checkout gh-pages') system('git add .') system('git add -u') system("git commit -m 'Generating docs for version #{Grape::VERSION}.'") system('git push origin gh-pages') end end end end grape-0.16.2/Gemfile.lock0000644000004100000410000000707512706307016015163 0ustar www-datawww-dataPATH remote: . specs: grape (0.16.2) activesupport builder hashie (>= 2.1.0) multi_json (>= 1.3.2) multi_xml (>= 0.5.2) mustermann19 (~> 0.4.3) rack (>= 1.3.0) rack-accept virtus (>= 1.0.0) GEM remote: https://rubygems.org/ specs: activesupport (4.2.5.1) i18n (~> 0.7) json (~> 1.7, >= 1.7.7) minitest (~> 5.1) thread_safe (~> 0.3, >= 0.3.4) tzinfo (~> 1.1) appraisal (2.1.0) bundler rake thor (>= 0.14.0) ast (2.2.0) astrolabe (1.3.1) parser (~> 2.2) axiom-types (0.1.1) descendants_tracker (~> 0.0.4) ice_nine (~> 0.11.0) thread_safe (~> 0.3, >= 0.3.1) benchmark-ips (2.5.0) builder (3.2.2) coderay (1.1.1) coercible (1.0.0) descendants_tracker (~> 0.0.1) cookiejar (0.3.3) descendants_tracker (0.0.4) thread_safe (~> 0.3, >= 0.3.1) diff-lcs (1.2.5) enumerable-lazy (0.0.1) equalizer (0.0.11) ffi (1.9.10) formatador (0.2.5) git-version-bump (0.15.1) grape-entity (0.5.0) activesupport multi_json (>= 1.3.2) guard (2.13.0) formatador (>= 0.2.4) listen (>= 2.7, <= 4.0) lumberjack (~> 1.0) nenv (~> 0.1) notiffany (~> 0.0) pry (>= 0.9.12) shellany (~> 0.0) thor (>= 0.18.1) guard-compat (1.2.1) guard-rspec (4.6.4) guard (~> 2.1) guard-compat (~> 1.1) rspec (>= 2.99.0, < 4.0) guard-rubocop (1.2.0) guard (~> 2.0) rubocop (~> 0.20) hashie (3.4.3) i18n (0.7.0) ice_nine (0.11.2) json (1.8.3) listen (3.0.6) rb-fsevent (>= 0.9.3) rb-inotify (>= 0.9.7) lumberjack (1.0.10) maruku (0.7.2) method_source (0.8.2) mime-types (2.99.1) minitest (5.8.4) multi_json (1.11.2) multi_xml (0.5.5) mustermann19 (0.4.3) enumerable-lazy nenv (0.3.0) notiffany (0.0.8) nenv (~> 0.1) shellany (~> 0.0) parser (2.3.0.6) ast (~> 2.2) powerpack (0.1.1) pry (0.10.3) coderay (~> 1.1.0) method_source (~> 0.8.1) slop (~> 3.4) rack (1.6.4) rack-accept (0.4.5) rack (>= 0.4) rack-contrib (1.4.0) git-version-bump (~> 0.15) rack (~> 1.4) rack-test (0.6.3) rack (>= 1.0) rainbow (2.1.0) rake (10.5.0) rb-fsevent (0.9.7) rb-inotify (0.9.7) ffi (>= 0.5.0) rspec (3.4.0) rspec-core (~> 3.4.0) rspec-expectations (~> 3.4.0) rspec-mocks (~> 3.4.0) rspec-core (3.4.3) rspec-support (~> 3.4.0) rspec-expectations (3.4.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.4.0) rspec-mocks (3.4.1) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.4.0) rspec-support (3.4.1) rubocop (0.35.1) astrolabe (~> 1.3) parser (>= 2.2.3.0, < 3.0) powerpack (~> 0.1) rainbow (>= 1.99.1, < 3.0) ruby-progressbar (~> 1.7) tins (<= 1.6.0) ruby-progressbar (1.7.5) shellany (0.0.1) slop (3.6.0) thor (0.19.1) thread_safe (0.3.5) tins (1.6.0) tzinfo (1.2.2) thread_safe (~> 0.1) virtus (1.0.5) axiom-types (~> 0.1) coercible (~> 1.0) descendants_tracker (~> 0.0, >= 0.0.3) equalizer (~> 0.0, >= 0.0.9) yard (0.8.7.6) PLATFORMS ruby DEPENDENCIES appraisal benchmark-ips bundler cookiejar grape! grape-entity (= 0.5.0) guard guard-rspec guard-rubocop maruku mime-types (< 3.0) rack-contrib rack-test rake (~> 10) rspec (~> 3.0) rubocop (= 0.35.1) yard BUNDLED WITH 1.11.2 grape-0.16.2/UPGRADING.md0000644000004100000410000004771612706307016014611 0ustar www-datawww-dataUpgrading Grape =============== ### Upgrading to >= 0.16.0 #### Replace rack-mount with new router The `Route#route_xyz` methods have been deprecated since 0.15.1. Please use `Route#xyz` instead. Note that the `Route#route_method` was replaced by `Route#request_method`. The following code would work correctly. ```ruby TwitterAPI::versions # yields [ 'v1', 'v2' ] TwitterAPI::routes # yields an array of Grape::Route objects TwitterAPI::routes[0].version # => 'v1' TwitterAPI::routes[0].description # => 'Includes custom settings.' TwitterAPI::routes[0].settings[:custom] # => { key: 'value' } TwitterAPI::routes[0].request_method # => 'GET' ``` #### `file` method accepts path to file Now to serve files via Grape just pass the path to the file. Functionality with FileStreamer-like objects is deprecated. Please, replace your FileStreamer-like objects with paths of served files. Old style: ```ruby class FileStreamer def initialize(file_path) @file_path = file_path end def each(&blk) File.open(@file_path, 'rb') do |file| file.each(10, &blk) end end end # ... class API < Grape::API get '/' do file FileStreamer.new('/path/to/file') end end ``` New style: ```ruby class API < Grape::API get '/' do file '/path/to/file' end end ``` ### Upgrading to >= 0.15.0 #### Changes to availability of `:with` option of `rescue_from` method The `:with` option of `rescue_from` does not accept value except Proc, String or Symbol now. If you have been depending the old behavior, you should use lambda block instead. ```ruby class API < Grape::API rescue_from :all, with: -> { Rack::Response.new('rescued with a method', 400) } end ``` #### Changes to behavior of `after` method of middleware on error The `after` method of the middleware is now also called on error. The following code would work correctly. ```ruby class ErrorMiddleware < Grape::Middleware::Base def after return unless @app_response && @app_response[0] == 500 env['rack.logger'].debug("Raised error on #{env['PATH_INFO']}") end end ``` See [#1147](https://github.com/ruby-grape/grape/issues/1147) and [#1240](https://github.com/ruby-grape/grape/issues/1240) for discussion of the issues. A warning will be logged if an exception is raised in an `after` callback, which points you to middleware that was not called in the previous version and is called now. ``` caught error of type NoMethodError in after callback inside Api::Middleware::SomeMiddleware : undefined method `headers' for nil:NilClass ``` See [#1285](https://github.com/ruby-grape/grape/pull/1285) for more information. #### Changes to Method Not Allowed routes A `405 Method Not Allowed` error now causes `Grape::Exceptions::MethodNotAllowed` to be raised, which will be rescued via `rescue_from :all`. Restore old behavior with the following error handler. ```ruby rescue_from Grape::Exceptions::MethodNotAllowed do |e| error! e.message, e.status, e.headers end ``` See [#1283](https://github.com/ruby-grape/grape/pull/1283) for more information. #### Changes to Grape::Exceptions::Validation parameters When raising `Grape::Exceptions::Validation` explicitly, replace `message_key` with `message`. For example, ```ruby fail Grape::Exceptions::Validation, params: [:oauth_token_secret], message_key: :presence ``` becomes ```ruby fail Grape::Exceptions::Validation, params: [:oauth_token_secret], message: :presence ``` See [#1295](https://github.com/ruby-grape/grape/pull/1295) for more information. ### Upgrading to >= 0.14.0 #### Changes to availability of DSL methods in filters The `#declared` method of the route DSL is no longer available in the `before` filter. Using `declared` in a `before` filter will now raise `Grape::DSL::InsideRoute::MethodNotYetAvailable`. See [#1074](https://github.com/ruby-grape/grape/issues/1074) for discussion of the issue. #### Changes to header versioning and invalid header version handling Identical endpoints with different versions now work correctly. A regression introduced in Grape 0.11.0 caused all but the first-mounted version for such an endpoint to wrongly throw an `InvalidAcceptHeader`. As a side effect, requests with a correct vendor but invalid version can no longer be rescued from a `rescue_from` block. See [#1114](https://github.com/ruby-grape/grape/pull/1114) for more information. #### Bypasses formatters when status code indicates no content To be consistent with rack and it's handling of standard responses associated with no content, both default and custom formatters will now be bypassed when processing responses for status codes defined [by rack](https://github.com/rack/rack/blob/master/lib/rack/utils.rb#L567) See [#1190](https://github.com/ruby-grape/grape/pull/1190) for more information. #### Redirects respond as plain text with message `#redirect` now uses `text/plain` regardless of whether that format has been enabled. This prevents formatters from attempting to serialize the message body and allows for a descriptive message body to be provided - and optionally overridden - that better fulfills the theme of the HTTP spec. See [#1194](https://github.com/ruby-grape/grape/pull/1194) for more information. ### Upgrading to >= 0.12.0 #### Changes in middleware The Rack response object is no longer converted to an array by the formatter, enabling streaming. If your custom middleware is accessing `@app_response`, update it to expect a `Rack::Response` instance instead of an array. For example, ```ruby class CacheBusterMiddleware < Grape::Middleware::Base def after @app_response[1]['Expires'] = Time.at(0).utc.to_s @app_response end end ``` becomes ```ruby class CacheBusterMiddleware < Grape::Middleware::Base def after @app_response.headers['Expires'] = Time.at(0).utc.to_s @app_response end end ``` See [#1029](https://github.com/ruby-grape/grape/pull/1029) for more information. #### Changes in present Using `present` with objects that responded to `merge` would cause early evaluation of the represented object, with unexpected side-effects, such as missing parameters or environment within rendering code. Grape now only merges represented objects with a previously rendered body, usually when multiple `present` calls are made in the same route. See [grape-with-roar#5](https://github.com/dblock/grape-with-roar/issues/5) and [#1023](https://github.com/ruby-grape/grape/issues/1023). #### Changes to regexp validator Parameters with `nil` value will now pass `regexp` validation. To disallow `nil` value for an endpoint, add `allow_blank: false`. ```ruby params do requires :email, allow_blank: false, regexp: /.+@.+/ end ``` See [#957](https://github.com/ruby-grape/grape/pull/957) for more information. #### Replace error_response with error! in rescue_from blocks Note: `error_response` is being deprecated, not removed. ```ruby def error!(message, status = options[:default_status], headers = {}, backtrace = []) headers = { 'Content-Type' => content_type }.merge(headers) rack_response(format_message(message, backtrace), status, headers) end ``` For example, ``` error_response({ message: { message: 'No such page.', id: 'missing_page' }, status: 404, headers: { 'Content-Type' => 'api/error' }) ``` becomes ``` error!({ message: 'No such page.', id: 'missing_page' }, 404, { 'Content-Type' => 'api/error' }) ``` `error!` also supports just passing a message. `error!('Server error.')` and `format: :json` returns the following JSON response ``` { 'error': 'Server error.' } ``` with a status code of 500 and a Content Type of text/error. Optionally, also replace `Rack::Response.new` with `error!.` The following are equivalent: ``` Rack::Response.new([ e.message ], 500, { "Content-type" => "text/error" }).finish error!(e) ``` See [#889](https://github.com/ruby-grape/grape/issues/889) for more information. #### Changes to routes when using `format` Version 0.10.0 has introduced a change via [#809](https://github.com/ruby-grape/grape/pull/809) whereas routes no longer got file-type suffixes added if you declared a single API `format`. This has been reverted, it's now again possible to call API with proper suffix when single `format` is defined: ```ruby class API < Grape::API format :json get :hello do { hello: 'world' } end end ``` Will respond with JSON to `/hello` **and** `/hello.json`. Will respond with 404 to `/hello.xml`, `/hello.txt` etc. See the [#1001](https://github.com/ruby-grape/grape/pull/1001) and [#914](https://github.com/ruby-grape/grape/issues/914) for more info. ### Upgrading to >= 0.11.0 #### Added Rack 1.6.0 support Grape now supports, but doesn't require Rack 1.6.0. If you encounter an issue with parsing requests larger than 128KB, explictly require Rack 1.6.0 in your Gemfile. ```ruby gem 'rack', '~> 1.6.0' ``` See [#559](https://github.com/ruby-grape/grape/issues/559) for more information. #### Removed route_info Key route_info is excluded from params. See [#879](https://github.com/ruby-grape/grape/pull/879) for more information. #### Fix callbacks within a version block Callbacks defined in a version block are only called for the routes defined in that block. This was a regression introduced in Grape 0.10.0, and is fixed in this version. See [#901](https://github.com/ruby-grape/grape/pull/901) for more information. #### Make type of group of parameters required Groups of parameters now require their type to be set explicitly as Array or Hash. Not setting the type now results in MissingGroupTypeError, unsupported type will raise UnsupportedTypeError. See [#886](https://github.com/ruby-grape/grape/pull/886) for more information. ### Upgrading to >= 0.10.1 #### Changes to `declared(params, include_missing: false)` Attributes with `nil` values or with values that evaluate to `false` are no longer considered *missing* and will be returned when `include_missing` is set to `false`. See [#864](https://github.com/ruby-grape/grape/pull/864) for more information. ### Upgrading to >= 0.10.0 #### Changes to content-types The following content-types have been removed: * atom (application/atom+xml) * rss (application/rss+xml) * jsonapi (application/jsonapi) This is because they have never been properly supported. #### Changes to desc New block syntax: Former: ```ruby desc "some descs", detail: 'more details', entity: API::Entities::Entity, params: API::Entities::Status.documentation, named: 'a name', headers: [XAuthToken: { description: 'Valdates your identity', required: true } get nil, http_codes: [ [401, 'Unauthorized', API::Entities::BaseError], [404, 'not found', API::Entities::Error] ] do ``` Now: ```ruby desc "some descs" do detail 'more details' params API::Entities::Status.documentation success API::Entities::Entity failure [ [401, 'Unauthorized', API::Entities::BaseError], [404, 'not found', API::Entities::Error] ] named 'a name' headers [ XAuthToken: { description: 'Valdates your identity', required: true }, XOptionalHeader: { description: 'Not really needed', required: false } ] end ``` #### Changes to Route Options and Descriptions A common hack to extend Grape with custom DSL methods was manipulating `@last_description`. ``` ruby module Grape module Extensions module SortExtension def sort(value) @last_description ||= {} @last_description[:sort] ||= {} @last_description[:sort].merge! value value end end Grape::API.extend self end end ``` You could access this value from within the API with `route.route_sort` or, more generally, via `env['api.endpoint'].options[:route_options][:sort]`. This will no longer work, use the documented and supported `route_setting`. ``` ruby module Grape module Extensions module SortExtension def sort(value) route_setting :sort, sort: value value end end Grape::API.extend self end end ``` To retrieve this value at runtime from within an API, use `env['api.endpoint'].route_setting(:sort)` and when introspecting a mounted API, use `route.route_settings[:sort]`. #### Accessing Class Variables from Helpers It used to be possible to fetch an API class variable from a helper function. For example: ```ruby @@static_variable = 42 helpers do def get_static_variable @@static_variable end end get do get_static_variable end ``` This will no longer work. Use a class method instead of a helper. ```ruby @@static_variable = 42 def self.get_static_variable @@static_variable end get do get_static_variable end ``` For more information see [#836](https://github.com/ruby-grape/grape/issues/836). #### Changes to Custom Validators To implement a custom validator, you need to inherit from `Grape::Validations::Base` instead of `Grape::Validations::Validator`. For more information see [Custom Validators](https://github.com/ruby-grape/grape#custom-validators) in the documentation. #### Changes to Raising Grape::Exceptions::Validation In previous versions raising `Grape::Exceptions::Validation` required a single `param`. ```ruby raise Grape::Exceptions::Validation, param: :id, message_key: :presence ``` The `param` argument has been deprecated and is now an array of `params`, accepting multiple values. ```ruby raise Grape::Exceptions::Validation, params: [:id], message_key: :presence ``` #### Changes to routes when using `format` Routes will no longer get file-type suffixes added if you declare a single API `format`. For example, ```ruby class API < Grape::API format :json get :hello do { hello: 'world' } end end ``` Pre-0.10.0, this would respond with JSON to `/hello`, `/hello.json`, `/hello.xml`, `/hello.txt`, etc. Now, this will only respond with JSON to `/hello`, but will be a 404 when trying to access `/hello.json`, `/hello.xml`, `/hello.txt`, etc. If you declare further `content_type`s, this behavior will be circumvented. For example, the following API will respond with JSON to `/hello`, `/hello.json`, `/hello.xml`, `/hello.txt`, etc. ```ruby class API < Grape::API format :json content_type :json, 'application/json' get :hello do { hello: 'world' } end end ``` See the [the updated API Formats documentation](https://github.com/ruby-grape/grape#api-formats) and [#809](https://github.com/ruby-grape/grape/pull/809) for more info. #### Changes to Evaluation of Permitted Parameter Values Permitted and default parameter values are now only evaluated lazily for each request when declared as a proc. The following code would raise an error at startup time. ```ruby params do optional :v, values: -> { [:x, :y] }, default: -> { :z } } end ``` Remove the proc to get the previous behavior. ```ruby params do optional :v, values: [:x, :y], default: :z } end ``` See [#801](https://github.com/ruby-grape/grape/issues/801) for more information. #### Changes to version If version is used with a block, the callbacks defined within that version block are not scoped to that individual block. In other words, the callback would be inherited by all versions blocks that follow the first one e.g ```ruby class API < Grape::API resource :foo do version 'v1', :using => :path do before do @output ||= 'hello1' end get '/' do @output += '-v1' end end version 'v2', :using => :path do before do @output ||= 'hello2' end get '/:id' do @output += '-v2' end end end end ``` when making a API call `GET /foo/v2/1`, the API would set instance variable `@output` to `hello1-v2` See [#898](https://github.com/ruby-grape/grape/issues/898) for more information. ### Upgrading to >= 0.9.0 #### Changes in Authentication The following middleware classes have been removed: * `Grape::Middleware::Auth::Basic` * `Grape::Middleware::Auth::Digest` * `Grape::Middleware::Auth::OAuth2` When you use theses classes directly like: ```ruby module API class Root < Grape::API class Protected < Grape::API use Grape::Middleware::Auth::OAuth2, token_class: 'AccessToken', parameter: %w(access_token api_key) ``` you have to replace these classes. As replacement can be used * `Grape::Middleware::Auth::Basic` => [`Rack::Auth::Basic`](https://github.com/rack/rack/blob/master/lib/rack/auth/basic.rb) * `Grape::Middleware::Auth::Digest` => [`Rack::Auth::Digest::MD5`](https://github.com/rack/rack/blob/master/lib/rack/auth/digest/md5.rb) * `Grape::Middleware::Auth::OAuth2` => [warden-oauth2](https://github.com/opperator/warden-oauth2) or [rack-oauth2](https://github.com/nov/rack-oauth2) If this is not possible you can extract the middleware files from [grape v0.7.0](https://github.com/ruby-grape/grape/tree/v0.7.0/lib/grape/middleware/auth) and host these files within your application See [#703](https://github.com/ruby-grape/Grape/pull/703) for more information. ### Upgrading to >= 0.7.0 #### Changes in Exception Handling Assume you have the following exception classes defined. ```ruby class ParentError < StandardError; end class ChildError < ParentError; end ``` In Grape <= 0.6.1, the `rescue_from` keyword only handled the exact exception being raised. The following code would rescue `ParentError`, but not `ChildError`. ```ruby rescue_from ParentError do |e| # only rescue ParentError end ``` This made it impossible to rescue an exception hieararchy, which is a more sensible default. In Grape 0.7.0 or newer, both `ParentError` and `ChildError` are rescued. ```ruby rescue_from ParentError do |e| # rescue both ParentError and ChildError end ``` To only rescue the base exception class, set `rescue_subclasses: false`. ```ruby rescue_from ParentError, rescue_subclasses: false do |e| # only rescue ParentError end ``` See [#544](https://github.com/ruby-grape/grape/pull/544) for more information. #### Changes in the Default HTTP Status Code In Grape <= 0.6.1, the default status code returned from `error!` was 403. ```ruby error! "You may not reticulate this spline!" # yields HTTP error 403 ``` This was a bad default value, since 403 means "Forbidden". Change any call to `error!` that does not specify a status code to specify one. The new default value is a more sensible default of 500, which is "Internal Server Error". ```ruby error! "You may not reticulate this spline!", 403 # yields HTTP error 403 ``` You may also use `default_error_status` to change the global default. ```ruby default_error_status 400 ``` See [#525](https://github.com/ruby-grape/Grape/pull/525) for more information. #### Changes in Parameter Declaration and Validation In Grape <= 0.6.1, `group`, `optional` and `requires` keywords with a block accepted either an `Array` or a `Hash`. ```ruby params do requires :id, type: Integer group :name do requires :first_name requires :last_name end end ``` This caused the ambiguity and unexpected errors described in [#543](https://github.com/ruby-grape/Grape/issues/543). In Grape 0.7.0, the `group`, `optional` and `requires` keywords take an additional `type` attribute which defaults to `Array`. This means that without a `type` attribute, these nested parameters will no longer accept a single hash, only an array (of hashes). Whereas in 0.6.1 the API above accepted the following json, it no longer does in 0.7.0. ```json { "id": 1, "name": { "first_name": "John", "last_name" : "Doe" } } ``` The `params` block should now read as follows. ```ruby params do requires :id, type: Integer requires :name, type: Hash do requires :first_name requires :last_name end end ``` See [#545](https://github.com/ruby-grape/Grape/pull/545) for more information. ### Upgrading to 0.6.0 In Grape <= 0.5.0, only the first validation error was raised and processing aborted. Validation errors are now collected and a single `Grape::Exceptions::ValidationErrors` exception is raised. You can access the collection of validation errors as `.errors`. ```ruby rescue_from Grape::Exceptions::Validations do |e| Rack::Response.new({ status: 422, message: e.message, errors: e.errors }.to_json, 422) end ``` For more information see [#462](https://github.com/ruby-grape/grape/issues/462). grape-0.16.2/Gemfile0000644000004100000410000000020112706307016014214 0ustar www-datawww-datasource 'https://rubygems.org' gemspec group :development, :test do gem 'guard' gem 'guard-rspec' gem 'guard-rubocop' end grape-0.16.2/grape.gemspec0000644000004100000410000000322112706307016015371 0ustar www-datawww-data$LOAD_PATH.push File.expand_path('../lib', __FILE__) require 'grape/version' Gem::Specification.new do |s| s.name = 'grape' s.version = Grape::VERSION s.platform = Gem::Platform::RUBY s.authors = ['Michael Bleigh'] s.email = ['michael@intridea.com'] s.homepage = 'https://github.com/ruby-grape/grape' s.summary = 'A simple Ruby framework for building REST-like APIs.' s.description = 'A Ruby framework for rapid API development with great conventions.' s.license = 'MIT' s.add_runtime_dependency 'rack', '>= 1.3.0' s.add_runtime_dependency 'mustermann19', '~> 0.4.3' s.add_runtime_dependency 'rack-accept' s.add_runtime_dependency 'activesupport' s.add_runtime_dependency 'multi_json', '>= 1.3.2' s.add_runtime_dependency 'multi_xml', '>= 0.5.2' s.add_runtime_dependency 'hashie', '>= 2.1.0' s.add_runtime_dependency 'virtus', '>= 1.0.0' s.add_runtime_dependency 'builder' s.add_development_dependency 'grape-entity', '0.5.0' s.add_development_dependency 'rake', '~> 10' s.add_development_dependency 'maruku' s.add_development_dependency 'yard' s.add_development_dependency 'rack-test' s.add_development_dependency 'rspec', '~> 3.0' s.add_development_dependency 'bundler' s.add_development_dependency 'cookiejar' s.add_development_dependency 'rack-contrib' s.add_development_dependency 'mime-types', '< 3.0' s.add_development_dependency 'appraisal' s.add_development_dependency 'benchmark-ips' s.add_development_dependency 'rubocop', '0.35.1' s.files = Dir['**/*'].keep_if { |file| File.file?(file) } s.test_files = Dir['spec/**/*'] s.require_paths = ['lib'] end grape-0.16.2/spec/0000755000004100000410000000000012706307017013663 5ustar www-datawww-datagrape-0.16.2/spec/grape/0000755000004100000410000000000012706307017014761 5ustar www-datawww-datagrape-0.16.2/spec/grape/middleware/0000755000004100000410000000000012706307017017076 5ustar www-datawww-datagrape-0.16.2/spec/grape/middleware/exception_spec.rb0000644000004100000410000001413012706307017022432 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Error do # raises a text exception module ExceptionSpec class ExceptionApp class << self def call(_env) fail 'rain!' end end end # raises a hash error class ErrorHashApp class << self def error!(message, status) throw :error, message: { error: message, detail: 'missing widget' }, status: status end def call(_env) error!('rain!', 401) end end end # raises an error! class AccessDeniedApp class << self def error!(message, status) throw :error, message: message, status: status end def call(_env) error!('Access Denied', 401) end end end # raises a custom error class CustomError < Grape::Exceptions::Base end class CustomErrorApp class << self def call(_env) fail CustomError, status: 400, message: 'failed validation' end end end end attr_reader :app it 'does not trap errors by default' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error run ExceptionSpec::ExceptionApp end expect { get '/' }.to raise_error(RuntimeError, 'rain!') end context 'with rescue_all set to true' do it 'sets the message appropriately' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true run ExceptionSpec::ExceptionApp end get '/' expect(last_response.body).to eq('rain!') end it 'defaults to a 500 status' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true run ExceptionSpec::ExceptionApp end get '/' expect(last_response.status).to eq(500) end it 'is possible to specify a different default status code' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, default_status: 500 run ExceptionSpec::ExceptionApp end get '/' expect(last_response.status).to eq(500) end it 'is possible to return errors in json format' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :json run ExceptionSpec::ExceptionApp end get '/' expect(last_response.body).to eq('{"error":"rain!"}') end it 'is possible to return hash errors in json format' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :json run ExceptionSpec::ErrorHashApp end get '/' expect(['{"error":"rain!","detail":"missing widget"}', '{"detail":"missing widget","error":"rain!"}']).to include(last_response.body) end it 'is possible to return errors in jsonapi format' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :jsonapi run ExceptionSpec::ExceptionApp end get '/' expect(last_response.body).to eq('{"error":"rain!"}') end it 'is possible to return hash errors in jsonapi format' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :jsonapi run ExceptionSpec::ErrorHashApp end get '/' expect(['{"error":"rain!","detail":"missing widget"}', '{"detail":"missing widget","error":"rain!"}']).to include(last_response.body) end it 'is possible to return errors in xml format' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :xml run ExceptionSpec::ExceptionApp end get '/' expect(last_response.body).to eq("\n\n rain!\n\n") end it 'is possible to return hash errors in xml format' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :xml run ExceptionSpec::ErrorHashApp end get '/' expect(["\n\n missing widget\n rain!\n\n", "\n\n rain!\n missing widget\n\n"]).to include(last_response.body) end it 'is possible to specify a custom formatter' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: true, format: :custom, error_formatters: { custom: lambda do |message, _backtrace, _options, _env| { custom_formatter: message }.inspect end } run ExceptionSpec::ExceptionApp end get '/' expect(last_response.body).to eq('{:custom_formatter=>"rain!"}') end it 'does not trap regular error! codes' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error run ExceptionSpec::AccessDeniedApp end get '/' expect(last_response.status).to eq(401) end it 'responds to custom Grape exceptions appropriately' do @app ||= Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, rescue_all: false run ExceptionSpec::CustomErrorApp end get '/' expect(last_response.status).to eq(400) expect(last_response.body).to eq('failed validation') end end end grape-0.16.2/spec/grape/middleware/versioner/0000755000004100000410000000000012706307017021112 5ustar www-datawww-datagrape-0.16.2/spec/grape/middleware/versioner/header_spec.rb0000644000004100000410000002575312706307017023715 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Versioner::Header do let(:app) { ->(env) { [200, env, env] } } subject { Grape::Middleware::Versioner::Header.new(app, @options || {}) } before do @options = { version_options: { using: :header, vendor: 'vendor' } } end context 'api.type and api.subtype' do it 'sets type and subtype to first choice of content type if no preference given' do status, _, env = subject.call('HTTP_ACCEPT' => '*/*') expect(env['api.type']).to eql 'application' expect(env['api.subtype']).to eql 'vnd.vendor+xml' expect(status).to eq(200) end it 'sets preferred type' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/*') expect(env['api.type']).to eql 'application' expect(env['api.subtype']).to eql 'vnd.vendor+xml' expect(status).to eq(200) end it 'sets preferred type and subtype' do status, _, env = subject.call('HTTP_ACCEPT' => 'text/plain') expect(env['api.type']).to eql 'text' expect(env['api.subtype']).to eql 'plain' expect(status).to eq(200) end end context 'api.format' do it 'is set' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json') expect(env['api.format']).to eql 'json' expect(status).to eq(200) end it 'is nil if not provided' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor') expect(env['api.format']).to eql nil expect(status).to eq(200) end ['v1', :v1].each do |version| context "when version is set to #{version}" do before do @options[:versions] = [version] end it 'is set' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json') expect(env['api.format']).to eql 'json' expect(status).to eq(200) end it 'is nil if not provided' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1') expect(env['api.format']).to eql nil expect(status).to eq(200) end end end end context 'api.vendor' do it 'is set' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor') expect(env['api.vendor']).to eql 'vendor' expect(status).to eq(200) end it 'is set if format provided' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json') expect(env['api.vendor']).to eql 'vendor' expect(status).to eq(200) end it 'fails with 406 Not Acceptable if vendor is invalid' do expect { subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor+json').last } .to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql('X-Cascade' => 'pass') expect(exception.status).to eql 406 expect(exception.message).to include 'API vendor not found' end end context 'when version is set' do before do @options[:versions] = ['v1'] end it 'is set' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1') expect(env['api.vendor']).to eql 'vendor' expect(status).to eq(200) end it 'is set if format provided' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json') expect(env['api.vendor']).to eql 'vendor' expect(status).to eq(200) end it 'fails with 406 Not Acceptable if vendor is invalid' do expect { subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last } .to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql('X-Cascade' => 'pass') expect(exception.status).to eql 406 expect(exception.message).to include('API vendor not found') end end end end context 'api.version' do before do @options[:versions] = ['v1'] end it 'is set' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1') expect(env['api.version']).to eql 'v1' expect(status).to eq(200) end it 'is set if format provided' do status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json') expect(env['api.version']).to eql 'v1' expect(status).to eq(200) end it 'fails with 406 Not Acceptable if version is invalid' do expect { subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').last }.to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidVersionHeader) expect(exception.headers).to eql('X-Cascade' => 'pass') expect(exception.status).to eql 406 expect(exception.message).to include('API version not found') end end end it 'succeeds if :strict is not set' do expect(subject.call('HTTP_ACCEPT' => '').first).to eq(200) expect(subject.call({}).first).to eq(200) end it 'succeeds if :strict is set to false' do @options[:version_options][:strict] = false expect(subject.call('HTTP_ACCEPT' => '').first).to eq(200) expect(subject.call({}).first).to eq(200) end context 'when :strict is set' do before do @options[:versions] = ['v1'] @options[:version_options][:strict] = true end it 'fails with 406 Not Acceptable if header is not set' do expect { subject.call({}).last }.to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql('X-Cascade' => 'pass') expect(exception.status).to eql 406 expect(exception.message).to include('Accept header must be set.') end end it 'fails with 406 Not Acceptable if header is empty' do expect { subject.call('HTTP_ACCEPT' => '').last }.to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql('X-Cascade' => 'pass') expect(exception.status).to eql 406 expect(exception.message).to include('Accept header must be set.') end end it 'succeeds if proper header is set' do expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first).to eq(200) end end context 'when :strict and cascade: false' do before do @options[:versions] = ['v1'] @options[:version_options][:strict] = true @options[:version_options][:cascade] = false end it 'fails with 406 Not Acceptable if header is not set' do expect { subject.call({}).last }.to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql({}) expect(exception.status).to eql 406 expect(exception.message).to include('Accept header must be set.') end end it 'fails with 406 Not Acceptable if header is application/xml' do expect { subject.call('HTTP_ACCEPT' => 'application/xml').last } .to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql({}) expect(exception.status).to eql 406 expect(exception.message).to include('API vendor or version not found.') end end it 'fails with 406 Not Acceptable if header is empty' do expect { subject.call('HTTP_ACCEPT' => '').last }.to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql({}) expect(exception.status).to eql 406 expect(exception.message).to include('Accept header must be set.') end end it 'fails with 406 Not Acceptable if header contains a single invalid accept' do expect { subject.call('HTTP_ACCEPT' => 'application/json;application/vnd.vendor-v1+json').first } .to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader) expect(exception.headers).to eql({}) expect(exception.status).to eql 406 expect(exception.message).to include('API vendor or version not found.') end end it 'succeeds if proper header is set' do expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first).to eq(200) end end context 'when multiple versions are specified' do before do @options[:versions] = %w(v1 v2) end it 'succeeds with v1' do expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first).to eq(200) end it 'succeeds with v2' do expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').first).to eq(200) end it 'fails with another version' do expect { subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v3+json') }.to raise_exception do |exception| expect(exception).to be_a(Grape::Exceptions::InvalidVersionHeader) expect(exception.headers).to eql('X-Cascade' => 'pass') expect(exception.status).to eql 406 expect(exception.message).to include('API version not found') end end end context 'when there are multiple versions with complex vendor specified with rescue_from :all' do subject { Class.new(Grape::API) do rescue_from :all end } let(:v1_app) { Class.new(Grape::API) do version 'v1', using: :header, vendor: 'test.a-cool_resource', cascade: false, strict: true content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json' formatter :v1_test, ->(object, _) { object } format :v1_test resources :users do get :hello do 'one' end end end } let(:v2_app) { Class.new(Grape::API) do version 'v2', using: :header, vendor: 'test.a-cool_resource', strict: true content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json' formatter :v2_test, ->(object, _) { object } format :v2_test resources :users do get :hello do 'two' end end end } def app subject.mount v2_app subject.mount v1_app subject end context 'with header versioned endpoints and a rescue_all block defined' do it 'responds correctly to a v1 request' do versioned_get '/users/hello', 'v1', using: :header, vendor: 'test.a-cool_resource' expect(last_response.body).to eq('one') expect(last_response.body).not_to include('API vendor or version not found') end it 'responds correctly to a v2 request' do versioned_get '/users/hello', 'v2', using: :header, vendor: 'test.a-cool_resource' expect(last_response.body).to eq('two') expect(last_response.body).not_to include('API vendor or version not found') end end end end grape-0.16.2/spec/grape/middleware/versioner/path_spec.rb0000644000004100000410000000267312706307017023415 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Versioner::Path do let(:app) { ->(env) { [200, env, env['api.version']] } } subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) } it 'sets the API version based on the first path' do expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1') end it 'does not cut the version out of the path' do expect(subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO']).to eq('/v1/awesome') end it 'provides a nil version if no path is given' do expect(subject.call('PATH_INFO' => '/').last).to be_nil end context 'with a pattern' do before { @options = { pattern: /v./i } } it 'sets the version if it matches' do expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1') end it 'ignores the version if it fails to match' do expect(subject.call('PATH_INFO' => '/awesome/radical').last).to be_nil end end [%w(v1 v2), [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions| context "with specified versions as #{versions}" do before { @options = { versions: versions } } it 'throws an error if a non-allowed version is specified' do expect(catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status]).to eq(404) end it 'allows versions that have been specified' do expect(subject.call('PATH_INFO' => '/v1/asoasd').last).to eq('v1') end end end end grape-0.16.2/spec/grape/middleware/versioner/accept_version_header_spec.rb0000644000004100000410000000630412706307017026770 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Versioner::AcceptVersionHeader do let(:app) { ->(env) { [200, env, env] } } subject { Grape::Middleware::Versioner::AcceptVersionHeader.new(app, @options || {}) } before do @options = { version_options: { using: :accept_version_header } } end context 'api.version' do before do @options[:versions] = ['v1'] end it 'is set' do status, _, env = subject.call('HTTP_ACCEPT_VERSION' => 'v1') expect(env['api.version']).to eql 'v1' expect(status).to eq(200) end it 'is set if format provided' do status, _, env = subject.call('HTTP_ACCEPT_VERSION' => 'v1') expect(env['api.version']).to eql 'v1' expect(status).to eq(200) end it 'fails with 406 Not Acceptable if version is not supported' do expect do subject.call('HTTP_ACCEPT_VERSION' => 'v2').last end.to throw_symbol( :error, status: 406, headers: { 'X-Cascade' => 'pass' }, message: 'The requested version is not supported.' ) end end it 'succeeds if :strict is not set' do expect(subject.call('HTTP_ACCEPT_VERSION' => '').first).to eq(200) expect(subject.call({}).first).to eq(200) end it 'succeeds if :strict is set to false' do @options[:version_options][:strict] = false expect(subject.call('HTTP_ACCEPT_VERSION' => '').first).to eq(200) expect(subject.call({}).first).to eq(200) end context 'when :strict is set' do before do @options[:versions] = ['v1'] @options[:version_options][:strict] = true end it 'fails with 406 Not Acceptable if header is not set' do expect do subject.call({}).last end.to throw_symbol( :error, status: 406, headers: { 'X-Cascade' => 'pass' }, message: 'Accept-Version header must be set.' ) end it 'fails with 406 Not Acceptable if header is empty' do expect do subject.call('HTTP_ACCEPT_VERSION' => '').last end.to throw_symbol( :error, status: 406, headers: { 'X-Cascade' => 'pass' }, message: 'Accept-Version header must be set.' ) end it 'succeeds if proper header is set' do expect(subject.call('HTTP_ACCEPT_VERSION' => 'v1').first).to eq(200) end end context 'when :strict and cascade: false' do before do @options[:versions] = ['v1'] @options[:version_options][:strict] = true @options[:version_options][:cascade] = false end it 'fails with 406 Not Acceptable if header is not set' do expect do subject.call({}).last end.to throw_symbol( :error, status: 406, headers: {}, message: 'Accept-Version header must be set.' ) end it 'fails with 406 Not Acceptable if header is empty' do expect do subject.call('HTTP_ACCEPT_VERSION' => '').last end.to throw_symbol( :error, status: 406, headers: {}, message: 'Accept-Version header must be set.' ) end it 'succeeds if proper header is set' do expect(subject.call('HTTP_ACCEPT_VERSION' => 'v1').first).to eq(200) end end end grape-0.16.2/spec/grape/middleware/versioner/param_spec.rb0000644000004100000410000001217512706307017023557 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Versioner::Param do let(:app) { ->(env) { [200, env, env['api.version']] } } subject { Grape::Middleware::Versioner::Param.new(app, @options || {}) } it 'sets the API version based on the default param (apiver)' do env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' }) expect(subject.call(env)[1]['api.version']).to eq('v1') end it 'cuts (only) the version out of the params' do env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1', 'other_param' => '5' }) env['rack.request.query_hash'] = Rack::Utils.parse_nested_query(env['QUERY_STRING']) expect(subject.call(env)[1]['rack.request.query_hash']['apiver']).to be_nil expect(subject.call(env)[1]['rack.request.query_hash']['other_param']).to eq('5') end it 'provides a nil version if no version is given' do env = Rack::MockRequest.env_for('/') expect(subject.call(env).last).to be_nil end context 'with specified parameter name' do before { @options = { version_options: { parameter: 'v' } } } it 'sets the API version based on the custom parameter name' do env = Rack::MockRequest.env_for('/awesome', params: { 'v' => 'v1' }) expect(subject.call(env)[1]['api.version']).to eq('v1') end it 'does not set the API version based on the default param' do env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' }) expect(subject.call(env)[1]['api.version']).to be_nil end end context 'with specified versions' do before { @options = { versions: %w(v1 v2) } } it 'throws an error if a non-allowed version is specified' do env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v3' }) expect(catch(:error) { subject.call(env) }[:status]).to eq(404) end it 'allows versions that have been specified' do env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' }) expect(subject.call(env)[1]['api.version']).to eq('v1') end end it 'returns a 200 when no version is set (matches the first version found)' do @options = { versions: ['v1'], version_options: { using: :header } } env = Rack::MockRequest.env_for('/awesome', params: {}) expect(subject.call(env).first).to eq(200) end context 'when there are multiple versions without a custom param' do subject { Class.new(Grape::API) } let(:v1_app) do Class.new(Grape::API) do version 'v1', using: :param content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json' formatter :v1_test, ->(object, _) { object } format :v1_test resources :users do get :hello do 'one' end end end end let(:v2_app) do Class.new(Grape::API) do version 'v2', using: :param content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json' formatter :v2_test, ->(object, _) { object } format :v2_test resources :users do get :hello do 'two' end end end end def app subject.mount v2_app subject.mount v1_app subject end it 'responds correctly to a v1 request' do versioned_get '/users/hello', 'v1', using: :param, parameter: :apiver expect(last_response.body).to eq('one') expect(last_response.body).not_to include('API vendor or version not found') end it 'responds correctly to a v2 request' do versioned_get '/users/hello', 'v2', using: :param, parameter: :apiver expect(last_response.body).to eq('two') expect(last_response.body).not_to include('API vendor or version not found') end end context 'when there are multiple versions with a custom param' do subject { Class.new(Grape::API) } let(:v1_app) do Class.new(Grape::API) do version 'v1', using: :param, parameter: 'v' content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json' formatter :v1_test, ->(object, _) { object } format :v1_test resources :users do get :hello do 'one' end end end end let(:v2_app) do Class.new(Grape::API) do version 'v2', using: :param, parameter: 'v' content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json' formatter :v2_test, ->(object, _) { object } format :v2_test resources :users do get :hello do 'two' end end end end def app subject.mount v2_app subject.mount v1_app subject end it 'responds correctly to a v1 request' do versioned_get '/users/hello', 'v1', using: :param, parameter: 'v' expect(last_response.body).to eq('one') expect(last_response.body).not_to include('API vendor or version not found') end it 'responds correctly to a v2 request' do versioned_get '/users/hello', 'v2', using: :param, parameter: 'v' expect(last_response.body).to eq('two') expect(last_response.body).not_to include('API vendor or version not found') end end end grape-0.16.2/spec/grape/middleware/auth/0000755000004100000410000000000012706307017020037 5ustar www-datawww-datagrape-0.16.2/spec/grape/middleware/auth/strategies_spec.rb0000644000004100000410000000405712706307017023556 0ustar www-datawww-datarequire 'spec_helper' require 'base64' describe Grape::Middleware::Auth::Strategies do context 'Basic Auth' do def app proc = ->(u, p) { u && p && u == p } Rack::Builder.new do |b| b.use Grape::Middleware::Error b.use(Grape::Middleware::Auth::Base, type: :http_basic, proc: proc) b.run ->(_env) { [200, {}, ['Hello there.']] } end end it 'throws a 401 if no auth is given' do @proc = -> { false } get '/whatever' expect(last_response.status).to eq(401) end it 'authenticates if given valid creds' do get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin') expect(last_response.status).to eq(200) end it 'throws a 401 is wrong auth is given' do get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong') expect(last_response.status).to eq(401) end end context 'Digest MD5 Auth' do RSpec::Matchers.define :be_challenge do match do |actual_response| actual_response.status == 401 && actual_response['WWW-Authenticate'] =~ /^Digest / && actual_response.body.empty? end end module StrategiesSpec class Test < Grape::API http_digest(realm: 'Test Api', opaque: 'secret') do |username| { 'foo' => 'bar' }[username] end get '/test' do [{ hey: 'you' }, { there: 'bar' }, { foo: 'baz' }] end end end def app StrategiesSpec::Test end it 'is a digest authentication challenge' do get '/test' expect(last_response).to be_challenge end it 'throws a 401 if no auth is given' do get '/test' expect(last_response.status).to eq(401) end it 'authenticates if given valid creds' do digest_authorize 'foo', 'bar' get '/test' expect(last_response.status).to eq(200) end it 'throws a 401 if given invalid creds' do digest_authorize 'bar', 'foo' get '/test' expect(last_response.status).to eq(401) end end end grape-0.16.2/spec/grape/middleware/auth/dsl_spec.rb0000644000004100000410000000324112706307017022160 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Auth::DSL do subject { Class.new(Grape::API) } let(:block) { ->() {} } let(:settings) do { opaque: 'secret', proc: block, realm: 'API Authorization', type: :http_digest } end describe '.auth' do it 'stets auth parameters' do expect(subject).to receive(:use).with(Grape::Middleware::Auth::Base, settings) subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc] expect(subject.auth).to eq(settings) end it 'can be called multiple times' do expect(subject).to receive(:use).with(Grape::Middleware::Auth::Base, settings) expect(subject).to receive(:use).with(Grape::Middleware::Auth::Base, settings.merge(realm: 'super_secret')) subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc] first_settings = subject.auth subject.auth :http_digest, realm: 'super_secret', opaque: settings[:opaque], &settings[:proc] expect(subject.auth).to eq(settings.merge(realm: 'super_secret')) expect(subject.auth.object_id).not_to eq(first_settings.object_id) end end describe '.http_basic' do it 'stets auth parameters' do subject.http_basic realm: 'my_realm', &settings[:proc] expect(subject.auth).to eq(realm: 'my_realm', type: :http_basic, proc: block) end end describe '.http_digest' do it 'stets auth parameters' do subject.http_digest realm: 'my_realm', opaque: 'my_opaque', &settings[:proc] expect(subject.auth).to eq(realm: 'my_realm', type: :http_digest, proc: block, opaque: 'my_opaque') end end end grape-0.16.2/spec/grape/middleware/auth/base_spec.rb0000644000004100000410000000135112706307016022307 0ustar www-datawww-datarequire 'spec_helper' require 'base64' describe Grape::Middleware::Auth::Base do subject do Class.new(Grape::API) do http_basic realm: 'my_realm' do |user, password| user && password && user == password end get '/authorized' do 'DONE' end end end def app subject end it 'authenticates if given valid creds' do get '/authorized', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin') expect(last_response.status).to eq(200) expect(last_response.body).to eq('DONE') end it 'throws a 401 is wrong auth is given' do get '/authorized', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong') expect(last_response.status).to eq(401) end end grape-0.16.2/spec/grape/middleware/error_spec.rb0000644000004100000410000000340512706307017021570 0ustar www-datawww-datarequire 'spec_helper' require 'grape-entity' describe Grape::Middleware::Error do module ErrorSpec class ErrorEntity < Grape::Entity expose :code expose :static def static 'static text' end end class ErrApp class << self attr_accessor :error attr_accessor :format def call(_env) throw :error, error end end end end def app opts = options Rack::Builder.app do use Spec::Support::EndpointFaker use Grape::Middleware::Error, opts run ErrorSpec::ErrApp end end let(:options) { { default_message: 'Aww, hamburgers.' } } it 'sets the status code appropriately' do ErrorSpec::ErrApp.error = { status: 410 } get '/' expect(last_response.status).to eq(410) end it 'sets the error message appropriately' do ErrorSpec::ErrApp.error = { message: 'Awesome stuff.' } get '/' expect(last_response.body).to eq('Awesome stuff.') end it 'defaults to a 500 status' do ErrorSpec::ErrApp.error = {} get '/' expect(last_response.status).to eq(500) end it 'has a default message' do ErrorSpec::ErrApp.error = {} get '/' expect(last_response.body).to eq('Aww, hamburgers.') end context 'with http code' do let(:options) { { default_message: 'Aww, hamburgers.' } } it 'adds the status code if wanted' do ErrorSpec::ErrApp.error = { message: { code: 200 } } get '/' expect(last_response.body).to eq({ code: 200 }.to_json) end it 'presents an error message' do ErrorSpec::ErrApp.error = { message: { code: 200, with: ErrorSpec::ErrorEntity } } get '/' expect(last_response.body).to eq({ code: 200, static: 'static text' }.to_json) end end end grape-0.16.2/spec/grape/middleware/globals_spec.rb0000644000004100000410000000160212706307017022057 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Globals do subject { Grape::Middleware::Globals.new(blank_app) } before { allow(subject).to receive(:dup).and_return(subject) } let(:blank_app) { ->(_env) { [200, {}, 'Hi there.'] } } it 'calls through to the app' do expect(subject.call({})).to eq([200, {}, 'Hi there.']) end context 'environment' do it 'should set the grape.request environment' do subject.call({}) expect(subject.env['grape.request']).to be_a(Grape::Request) end it 'should set the grape.request.headers environment' do subject.call({}) expect(subject.env['grape.request.headers']).to be_a(Hash) end it 'should set the grape.request.params environment' do subject.call('QUERY_STRING' => 'test=1', 'rack.input' => StringIO.new) expect(subject.env['grape.request.params']).to be_a(Hash) end end end grape-0.16.2/spec/grape/middleware/versioner_spec.rb0000644000004100000410000000113112706307017022445 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Versioner do let(:klass) { Grape::Middleware::Versioner } it 'recognizes :path' do expect(klass.using(:path)).to eq(Grape::Middleware::Versioner::Path) end it 'recognizes :header' do expect(klass.using(:header)).to eq(Grape::Middleware::Versioner::Header) end it 'recognizes :param' do expect(klass.using(:param)).to eq(Grape::Middleware::Versioner::Param) end it 'recognizes :accept_version_header' do expect(klass.using(:accept_version_header)).to eq(Grape::Middleware::Versioner::AcceptVersionHeader) end end grape-0.16.2/spec/grape/middleware/base_spec.rb0000644000004100000410000001142512706307017021352 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Base do subject { Grape::Middleware::Base.new(blank_app) } let(:blank_app) { ->(_) { [200, {}, 'Hi there.'] } } before do # Keep it one object for testing. allow(subject).to receive(:dup).and_return(subject) end it 'has the app as an accessor' do expect(subject.app).to eq(blank_app) end it 'calls through to the app' do expect(subject.call({})).to eq([200, {}, 'Hi there.']) end context 'callbacks' do it 'calls #before' do expect(subject).to receive(:before) end it 'calls #after' do expect(subject).to receive(:after) end after { subject.call!({}) } end context 'callbacks on error' do let(:blank_app) { ->(_) { fail StandardError } } it 'calls #after' do expect(subject).to receive(:after) expect { subject.call({}) }.to raise_error(StandardError) end end context 'after callback' do before do allow(subject).to receive(:after).and_return([200, {}, 'Hello from after callback']) end it 'overwrites application response' do expect(subject.call!({}).last).to eq('Hello from after callback') end end context 'after callback with errors' do it 'does not overwrite the application response' do expect(subject.call({})).to eq([200, {}, 'Hi there.']) end context 'with patched warnings' do before do @warnings = warnings = [] allow_any_instance_of(Grape::Middleware::Base).to receive(:warn) { |m| warnings << m } allow(subject).to receive(:after).and_raise(StandardError) end it 'does show a warning' do expect { subject.call({}) }.to raise_error(StandardError) expect(@warnings).not_to be_empty end end end it 'is able to access the response' do subject.call({}) expect(subject.response).to be_kind_of(Rack::Response) end describe '#response' do subject { Grape::Middleware::Base.new(response) } context Array do let(:response) { ->(_) { [204, { abc: 1 }, 'test'] } } it 'status' do subject.call({}) expect(subject.response.status).to eq(204) end it 'body' do subject.call({}) expect(subject.response.body).to eq(['test']) end it 'header' do subject.call({}) expect(subject.response.header).to have_key(:abc) end end context Rack::Response do let(:response) { ->(_) { Rack::Response.new('test', 204, abc: 1) } } it 'status' do subject.call({}) expect(subject.response.status).to eq(204) end it 'body' do subject.call({}) expect(subject.response.body).to eq(['test']) end it 'header' do subject.call({}) expect(subject.response.header).to have_key(:abc) end end end context 'options' do it 'persists options passed at initialization' do expect(Grape::Middleware::Base.new(blank_app, abc: true).options[:abc]).to be true end context 'defaults' do module BaseSpec class ExampleWare < Grape::Middleware::Base def default_options { monkey: true } end end end it 'persists the default options' do expect(BaseSpec::ExampleWare.new(blank_app).options[:monkey]).to be true end it 'overrides default options when provided' do expect(BaseSpec::ExampleWare.new(blank_app, monkey: false).options[:monkey]).to be false end end end context 'header' do module HeaderSpec class ExampleWare < Grape::Middleware::Base def before header 'X-Test-Before', 'Hi' end def after header 'X-Test-After', 'Bye' nil end end end def app Rack::Builder.app do use HeaderSpec::ExampleWare run ->(_) { [200, {}, ['Yeah']] } end end it 'is able to set a header' do get '/' expect(last_response.headers['X-Test-Before']).to eq('Hi') expect(last_response.headers['X-Test-After']).to eq('Bye') end end context 'header overwrite' do module HeaderOverwritingSpec class ExampleWare < Grape::Middleware::Base def before header 'X-Test-Overwriting', 'Hi' end def after header 'X-Test-Overwriting', 'Bye' nil end end class API < Grape::API get('/') do header 'X-Test-Overwriting', 'Yeah' 'Hello' end end end def app Rack::Builder.app do use HeaderOverwritingSpec::ExampleWare run HeaderOverwritingSpec::API.new end end it 'overwrites header by after headers' do get '/' expect(last_response.headers['X-Test-Overwriting']).to eq('Bye') end end end grape-0.16.2/spec/grape/middleware/formatter_spec.rb0000644000004100000410000002735312706307017022452 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Middleware::Formatter do subject { Grape::Middleware::Formatter.new(app) } before { allow(subject).to receive(:dup).and_return(subject) } let(:app) { ->(_env) { [200, {}, [@body || { 'foo' => 'bar' }]] } } context 'serialization' do it 'looks at the bodies for possibly serializable data' do @body = { 'abc' => 'def' } _, _, bodies = *subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json') bodies.each { |b| expect(b).to eq(MultiJson.dump(@body)) } end it 'calls #to_json since default format is json' do @body = ['foo'] @body.instance_eval do def to_json "\"bar\"" end end subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('"bar"') } end it 'calls #to_json if the content type is jsonapi' do @body = { 'foos' => [{ 'bar' => 'baz' }] } @body.instance_eval do def to_json "{\"foos\":[{\"bar\":\"baz\"}] }" end end subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/vnd.api+json').to_a.last.each { |b| expect(b).to eq('{"foos":[{"bar":"baz"}] }') } end it 'calls #to_xml if the content type is xml' do @body = 'string' @body.instance_eval do def to_xml '' end end subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('') } end end context 'error handling' do let(:formatter) { double(:formatter) } before do allow(Grape::Formatter).to receive(:formatter_for) { formatter } end it 'rescues formatter-specific exceptions' do allow(formatter).to receive(:call) { fail Grape::Exceptions::InvalidFormatter.new(String, 'xml') } expect do catch(:error) { subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json') } end.to_not raise_error end it 'does not rescue other exceptions' do allow(formatter).to receive(:call) { fail StandardError } expect do catch(:error) { subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json') } end.to raise_error(StandardError) end end context 'detection' do it 'uses the xml extension if one is provided' do subject.call('PATH_INFO' => '/info.xml') expect(subject.env['api.format']).to eq(:xml) end it 'uses the json extension if one is provided' do subject.call('PATH_INFO' => '/info.json') expect(subject.env['api.format']).to eq(:json) end it 'uses the format parameter if one is provided' do subject.call('PATH_INFO' => '/info', 'QUERY_STRING' => 'format=json') expect(subject.env['api.format']).to eq(:json) subject.call('PATH_INFO' => '/info', 'QUERY_STRING' => 'format=xml') expect(subject.env['api.format']).to eq(:xml) end it 'uses the default format if none is provided' do subject.call('PATH_INFO' => '/info') expect(subject.env['api.format']).to eq(:txt) end it 'uses the requested format if provided in headers' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json') expect(subject.env['api.format']).to eq(:json) end it 'uses the file extension format if provided before headers' do subject.call('PATH_INFO' => '/info.txt', 'HTTP_ACCEPT' => 'application/json') expect(subject.env['api.format']).to eq(:txt) end end context 'accept header detection' do it 'detects from the Accept header' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/xml') expect(subject.env['api.format']).to eq(:xml) end it 'uses quality rankings to determine formats' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; q=0.3,application/xml; q=1.0') expect(subject.env['api.format']).to eq(:xml) subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; q=1.0,application/xml; q=0.3') expect(subject.env['api.format']).to eq(:json) end it 'handles quality rankings mixed with nothing' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json,application/xml; q=1.0') expect(subject.env['api.format']).to eq(:xml) end it 'parses headers with other attributes' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; abc=2.3; q=1.0,application/xml; q=0.7') expect(subject.env['api.format']).to eq(:json) end it 'parses headers with vendor and api version' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/vnd.test-v1+xml') expect(subject.env['api.format']).to eq(:xml) end context 'with custom vendored content types' do before do subject.options[:content_types] = {} subject.options[:content_types][:custom] = 'application/vnd.test+json' end it 'it uses the custom type' do subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/vnd.test+json') expect(subject.env['api.format']).to eq(:custom) end end it 'parses headers with symbols as hash keys' do subject.call('PATH_INFO' => '/info', 'http_accept' => 'application/xml', system_time: '091293') expect(subject.env[:system_time]).to eq('091293') end end context 'content-type' do it 'is set for json' do _, headers, = subject.call('PATH_INFO' => '/info.json') expect(headers['Content-type']).to eq('application/json') end it 'is set for xml' do _, headers, = subject.call('PATH_INFO' => '/info.xml') expect(headers['Content-type']).to eq('application/xml') end it 'is set for txt' do _, headers, = subject.call('PATH_INFO' => '/info.txt') expect(headers['Content-type']).to eq('text/plain') end it 'is set for custom' do subject.options[:content_types] = {} subject.options[:content_types][:custom] = 'application/x-custom' _, headers, = subject.call('PATH_INFO' => '/info.custom') expect(headers['Content-type']).to eq('application/x-custom') end it 'is set for vendored with registered type' do subject.options[:content_types] = {} subject.options[:content_types][:custom] = 'application/vnd.test+json' _, headers, = subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/vnd.test+json') expect(headers['Content-type']).to eq('application/vnd.test+json') end it 'is set to closest generic for custom vendored/versioned without registered type' do _, headers, = subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/vnd.test+json') expect(headers['Content-type']).to eq('application/json') end end context 'format' do it 'uses custom formatter' do subject.options[:content_types] = {} subject.options[:content_types][:custom] = "don't care" subject.options[:formatters][:custom] = ->(_obj, _env) { 'CUSTOM FORMAT' } _, _, body = subject.call('PATH_INFO' => '/info.custom') expect(body.body).to eq(['CUSTOM FORMAT']) end it 'uses default json formatter' do @body = ['blah'] _, _, body = subject.call('PATH_INFO' => '/info.json') expect(body.body).to eq(['["blah"]']) end it 'uses custom json formatter' do subject.options[:formatters][:json] = ->(_obj, _env) { 'CUSTOM JSON FORMAT' } _, _, body = subject.call('PATH_INFO' => '/info.json') expect(body.body).to eq(['CUSTOM JSON FORMAT']) end end context 'no content responses' do let(:no_content_response) { ->(status) { [status, {}, ['']] } } Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.each do |status| it "does not modify a #{status} response" do expected_response = no_content_response[status] allow(app).to receive(:call).and_return(expected_response) expect(subject.call({})).to eq(expected_response) end end end context 'input' do %w(POST PATCH PUT DELETE).each do |method| ['application/json', 'application/json; charset=utf-8'].each do |content_type| context content_type do it "parses the body from #{method} and copies values into rack.request.form_hash" do io = StringIO.new('{"is_boolean":true,"string":"thing"}') subject.call( 'PATH_INFO' => '/info', 'REQUEST_METHOD' => method, 'CONTENT_TYPE' => content_type, 'rack.input' => io, 'CONTENT_LENGTH' => io.length ) expect(subject.env['rack.request.form_hash']['is_boolean']).to be true expect(subject.env['rack.request.form_hash']['string']).to eq('thing') end end end it "parses the chunked body from #{method} and copies values into rack.request.from_hash" do io = StringIO.new('{"is_boolean":true,"string":"thing"}') subject.call( 'PATH_INFO' => '/infol', 'REQUEST_METHOD' => method, 'CONTENT_TYPE' => 'application/json', 'rack.input' => io, 'HTTP_TRANSFER_ENCODING' => 'chunked' ) expect(subject.env['rack.request.form_hash']['is_boolean']).to be true expect(subject.env['rack.request.form_hash']['string']).to eq('thing') end it 'rewinds IO' do io = StringIO.new('{"is_boolean":true,"string":"thing"}') io.read subject.call( 'PATH_INFO' => '/infol', 'REQUEST_METHOD' => method, 'CONTENT_TYPE' => 'application/json', 'rack.input' => io, 'HTTP_TRANSFER_ENCODING' => 'chunked' ) expect(subject.env['rack.request.form_hash']['is_boolean']).to be true expect(subject.env['rack.request.form_hash']['string']).to eq('thing') end it "parses the body from an xml #{method} and copies values into rack.request.from_hash" do io = StringIO.new('Test') subject.call( 'PATH_INFO' => '/info.xml', 'REQUEST_METHOD' => method, 'CONTENT_TYPE' => 'application/xml', 'rack.input' => io, 'CONTENT_LENGTH' => io.length ) expect(subject.env['rack.request.form_hash']['thing']['name']).to eq('Test') end [Rack::Request::FORM_DATA_MEDIA_TYPES, Rack::Request::PARSEABLE_DATA_MEDIA_TYPES].flatten.each do |content_type| it "ignores #{content_type}" do io = StringIO.new('name=Other+Test+Thing') subject.call( 'PATH_INFO' => '/info', 'REQUEST_METHOD' => method, 'CONTENT_TYPE' => content_type, 'rack.input' => io, 'CONTENT_LENGTH' => io.length ) expect(subject.env['rack.request.form_hash']).to be_nil end end end end context 'send file' do let(:app) { ->(_env) { [200, {}, @body] } } it 'returns Grape::Uril::SendFileReponse' do @body = Grape::ServeFile::FileResponse.new('file') env = { 'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json' } expect(subject.call(env)).to be_a(Grape::ServeFile::SendfileResponse) end end context 'inheritable formatters' do class InvalidFormatter def self.call(_, _) { message: 'invalid' }.to_json end end let(:app) { ->(_env) { [200, {}, ['']] } } before do Grape::Formatter.register :invalid, InvalidFormatter Grape::ContentTypes::CONTENT_TYPES[:invalid] = 'application/x-invalid' end it 'returns response by invalid formatter' do env = { 'PATH_INFO' => '/hello.invalid', 'HTTP_ACCEPT' => 'application/x-invalid' } _, _, bodies = *subject.call(env) expect(bodies.body.first).to eq({ message: 'invalid' }.to_json) end end end grape-0.16.2/spec/grape/exceptions/0000755000004100000410000000000012706307016017141 5ustar www-datawww-datagrape-0.16.2/spec/grape/exceptions/invalid_accept_header_spec.rb0000644000004100000410000002462712706307016024770 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Exceptions::InvalidAcceptHeader do shared_examples_for 'a valid request' do it 'does return with status 200' do expect(last_response.status).to eq 200 end it 'does return the expected result' do expect(last_response.body).to eq('beer received') end end shared_examples_for 'a cascaded request' do it 'does not find a matching route' do expect(last_response.status).to eq 404 end end shared_examples_for 'a not-cascaded request' do it 'does not include the X-Cascade=pass header' do expect(last_response.headers['X-Cascade']).to be_nil end it 'does not accept the request' do expect(last_response.status).to eq 406 end end shared_examples_for 'a rescued request' do it 'does not include the X-Cascade=pass header' do expect(last_response.headers['X-Cascade']).to be_nil end it 'does show rescue handler processing' do expect(last_response.status).to eq 400 expect(last_response.body).to eq('message was processed') end end context 'API with cascade=false and rescue_from :all handler' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false subject.rescue_from :all do |e| rack_response 'message was processed', 400, e[:headers] end subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid vendor in the request' do before do get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99', 'CONTENT_TYPE' => 'application/json' end it_should_behave_like 'a rescued request' end end end context 'API with cascade=false and without a rescue handler' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid version in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' } it_should_behave_like 'a not-cascaded request' end context 'an invalid vendor in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' } it_should_behave_like 'a not-cascaded request' end end end context 'API with cascade=false and with rescue_from :all handler and http_codes' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false subject.rescue_from :all do |e| rack_response 'message was processed', 400, e[:headers] end subject.desc 'Get beer' do failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'], [404, 'Resource not found'], [406, 'API vendor or version not found'], [500, 'Internal processing error']] end subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid vendor in the request' do before do get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99', 'CONTENT_TYPE' => 'application/json' end it_should_behave_like 'a rescued request' end end end context 'API with cascade=false, http_codes but without a rescue handler' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false subject.desc 'Get beer' do failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'], [404, 'Resource not found'], [406, 'API vendor or version not found'], [500, 'Internal processing error']] end subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid version in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' } it_should_behave_like 'a not-cascaded request' end context 'an invalid vendor in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' } it_should_behave_like 'a not-cascaded request' end end end context 'API with cascade=true and rescue_from :all handler' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true subject.rescue_from :all do |e| rack_response 'message was processed', 400, e[:headers] end subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid version in the request' do before do get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77', 'CONTENT_TYPE' => 'application/json' end it_should_behave_like 'a cascaded request' end context 'an invalid vendor in the request' do before do get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99', 'CONTENT_TYPE' => 'application/json' end it_should_behave_like 'a cascaded request' end end end context 'API with cascade=true and without a rescue handler' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid version in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' } it_should_behave_like 'a cascaded request' end context 'an invalid vendor in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' } it_should_behave_like 'a cascaded request' end end end context 'API with cascade=true and with rescue_from :all handler and http_codes' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true subject.rescue_from :all do |e| rack_response 'message was processed', 400, e[:headers] end subject.desc 'Get beer' do failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'], [404, 'Resource not found'], [406, 'API vendor or version not found'], [500, 'Internal processing error']] end subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid version in the request' do before do get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77', 'CONTENT_TYPE' => 'application/json' end it_should_behave_like 'a cascaded request' end context 'an invalid vendor in the request' do before do get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99', 'CONTENT_TYPE' => 'application/json' end it_should_behave_like 'a cascaded request' end end end context 'API with cascade=true, http_codes but without a rescue handler' do subject { Class.new(Grape::API) } before do subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true subject.desc 'Get beer' do failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'], [404, 'Resource not found'], [406, 'API vendor or version not found'], [500, 'Internal processing error']] end subject.get '/beer' do 'beer received' end end def app subject end context 'that received a request with correct vendor and version' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' } it_should_behave_like 'a valid request' end context 'that receives' do context 'an invalid version in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' } it_should_behave_like 'a cascaded request' end context 'an invalid vendor in the request' do before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' } it_should_behave_like 'a cascaded request' end end end end grape-0.16.2/spec/grape/exceptions/validation_spec.rb0000644000004100000410000000035512706307016022635 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Exceptions::Validation do it 'fails when params are missing' do expect { Grape::Exceptions::Validation.new(message: 'presence') }.to raise_error(RuntimeError, 'Params are missing:') end end grape-0.16.2/spec/grape/exceptions/invalid_versioner_option_spec.rb0000644000004100000410000000053312706307016025613 0ustar www-datawww-data# encoding: utf-8 require 'spec_helper' describe Grape::Exceptions::InvalidVersionerOption do describe '#message' do let(:error) do described_class.new('headers') end it 'contains the problem in the message' do expect(error.message).to include( 'Unknown :using for versioner: headers' ) end end end grape-0.16.2/spec/grape/exceptions/invalid_formatter_spec.rb0000644000004100000410000000052012706307016024206 0ustar www-datawww-data# encoding: utf-8 require 'spec_helper' describe Grape::Exceptions::InvalidFormatter do describe '#message' do let(:error) do described_class.new(String, 'xml') end it 'contains the problem in the message' do expect(error.message).to include( 'cannot convert String to xml' ) end end end grape-0.16.2/spec/grape/exceptions/unknown_validator_spec.rb0000644000004100000410000000050612706307016024245 0ustar www-datawww-data# encoding: utf-8 require 'spec_helper' describe Grape::Exceptions::UnknownValidator do describe '#message' do let(:error) do described_class.new('gt_10') end it 'contains the problem in the message' do expect(error.message).to include( 'unknown validator: gt_10' ) end end end grape-0.16.2/spec/grape/exceptions/body_parse_errors_spec.rb0000644000004100000410000000616012706307016024226 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Exceptions::ValidationErrors do context 'api with rescue_from :all handler' do subject { Class.new(Grape::API) } before do subject.rescue_from :all do |_e| rack_response 'message was processed', 400 end subject.params do requires :beer end subject.post '/beer' do 'beer received' end end def app subject end context 'with content_type json' do it 'can recover from failed body parsing' do post '/beer', 'test', 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq 400 expect(last_response.body).to eq('message was processed') end end context 'with content_type xml' do it 'can recover from failed body parsing' do post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml' expect(last_response.status).to eq 400 expect(last_response.body).to eq('message was processed') end end context 'with content_type text' do it 'can recover from failed body parsing' do post '/beer', 'test', 'CONTENT_TYPE' => 'text/plain' expect(last_response.status).to eq 400 expect(last_response.body).to eq('message was processed') end end context 'with no specific content_type' do it 'can recover from failed body parsing' do post '/beer', 'test', {} expect(last_response.status).to eq 400 expect(last_response.body).to eq('message was processed') end end end context 'api without a rescue handler' do subject { Class.new(Grape::API) } before do subject.params do requires :beer end subject.post '/beer' do 'beer received' end end def app subject end context 'and with content_type json' do it 'can recover from failed body parsing' do post '/beer', 'test', 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq 400 expect(last_response.body).to include('message body does not match declared format') expect(last_response.body).to include('application/json') end end context 'with content_type xml' do it 'can recover from failed body parsing' do post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml' expect(last_response.status).to eq 400 expect(last_response.body).to include('message body does not match declared format') expect(last_response.body).to include('application/xml') end end context 'with content_type text' do it 'can recover from failed body parsing' do post '/beer', 'test', 'CONTENT_TYPE' => 'text/plain' expect(last_response.status).to eq 400 expect(last_response.body).to eq('beer is missing') end end context 'and with no specific content_type' do it 'can recover from failed body parsing' do post '/beer', 'test', {} expect(last_response.status).to eq 400 # plain response with text/html expect(last_response.body).to eq('beer is missing') end end end end grape-0.16.2/spec/grape/exceptions/missing_mime_type_spec.rb0000644000004100000410000000072512706307016024225 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Exceptions::MissingMimeType do describe '#message' do let(:error) do described_class.new('new_json') end it 'contains the problem in the message' do expect(error.message).to include 'missing mime type for new_json' end it 'contains the resolution in the message' do expect(error.message).to include "or add your own with content_type :new_json, 'application/new_json' " end end end grape-0.16.2/spec/grape/exceptions/unknown_options_spec.rb0000644000004100000410000000047612706307016023761 0ustar www-datawww-data# encoding: utf-8 require 'spec_helper' describe Grape::Exceptions::UnknownOptions do describe '#message' do let(:error) do described_class.new([:a, :b]) end it 'contains the problem in the message' do expect(error.message).to include( 'unknown options: ' ) end end end grape-0.16.2/spec/grape/exceptions/missing_option_spec.rb0000644000004100000410000000051012706307016023535 0ustar www-datawww-data# encoding: utf-8 require 'spec_helper' describe Grape::Exceptions::MissingOption do describe '#message' do let(:error) do described_class.new(:path) end it 'contains the problem in the message' do expect(error.message).to include( 'You must specify :path options.' ) end end end grape-0.16.2/spec/grape/exceptions/validation_errors_spec.rb0000644000004100000410000000424012706307016024226 0ustar www-datawww-datarequire 'spec_helper' require 'ostruct' describe Grape::Exceptions::ValidationErrors do let(:validation_message) { 'FooBar is invalid' } let(:validation_error) { OpenStruct.new(params: [validation_message]) } context 'initialize' do let(:headers) { { 'A-Header-Key' => 'A-Header-Value' } } subject do described_class.new(errors: [validation_error], headers: headers) end it 'should assign headers through base class' do expect(subject.headers).to eq(headers) end end context 'message' do context 'is not repeated' do let(:error) do described_class.new(errors: [validation_error, validation_error]) end subject(:message) { error.message.split(',').map(&:strip) } it { expect(message).to include validation_message } it { expect(message.size).to eq 1 } end end describe '#full_messages' do context 'with errors' do let(:validation_error_1) { Grape::Exceptions::Validation.new(params: ['id'], message: :presence) } let(:validation_error_2) { Grape::Exceptions::Validation.new(params: ['name'], message: :presence) } subject { described_class.new(errors: [validation_error_1, validation_error_2]).full_messages } it 'returns an array with each errors full message' do expect(subject).to contain_exactly('id is missing', 'name is missing') end end end context 'api' do subject { Class.new(Grape::API) } def app subject end it 'can return structured json with separate fields' do subject.format :json subject.rescue_from Grape::Exceptions::ValidationErrors do |e| error!(e, 400) end subject.params do optional :beer optional :wine optional :juice exactly_one_of :beer, :wine, :juice end subject.get '/exactly_one_of' do 'exactly_one_of works!' end get '/exactly_one_of', beer: 'string', wine: 'anotherstring' expect(last_response.status).to eq(400) expect(JSON.parse(last_response.body)).to eq([ 'params' => %w(beer wine), 'messages' => ['are mutually exclusive'] ]) end end end grape-0.16.2/spec/grape/parser_spec.rb0000644000004100000410000000447412706307017017625 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Parser do subject { described_class } describe '.builtin_parsers' do it 'returns an instance of Hash' do expect(subject.builtin_parsers).to be_an_instance_of(Hash) end it 'includes json and xml parsers by default' do expect(subject.builtin_parsers).to include(json: Grape::Parser::Json, xml: Grape::Parser::Xml) end end describe '.parsers' do it 'returns an instance of Hash' do expect(subject.parsers({})).to be_an_instance_of(Hash) end it 'includes built-in parsers' do expect(subject.parsers({})).to include(subject.builtin_parsers) end context 'with :parsers option' do let(:parsers) { { customized: Class.new } } it 'includes passed :parsers values' do expect(subject.parsers(parsers: parsers)).to include(parsers) end end context 'with added parser by using `register` keyword' do let(:added_parser) { Class.new } before { subject.register :added, added_parser } it 'includes added parser' do expect(subject.parsers({})).to include(added: added_parser) end end end describe '.parser_for' do let(:options) { {} } it 'calls .parsers' do expect(subject).to receive(:parsers).with(options).and_return(subject.builtin_parsers) subject.parser_for(:json, options) end it 'returns parser correctly' do expect(subject.parser_for(:json)).to eq(Grape::Parser::Json) end context 'when parser is available' do before { subject.register :customized_json, Grape::Parser::Json } it 'returns registered parser if available' do expect(subject.parser_for(:customized_json)).to eq(Grape::Parser::Json) end end context 'when parser is an instance of Symbol' do before do allow(subject).to receive(:foo).and_return(:bar) subject.register :foo, :foo end it 'returns an instance of Method' do expect(subject.parser_for(:foo)).to be_an_instance_of(Method) end it 'returns object which can be called' do method = subject.parser_for(:foo) expect(method.call).to eq(:bar) end end context 'when parser does not exist' do it 'returns nil' do expect(subject.parser_for(:undefined)).to be_nil end end end end grape-0.16.2/spec/grape/api/0000755000004100000410000000000012706307016015531 5ustar www-datawww-datagrape-0.16.2/spec/grape/api/nested_helpers_spec.rb0000644000004100000410000000166312706307016022102 0ustar www-datawww-datarequire 'spec_helper' describe Grape::API::Helpers do module NestedHelpersSpec module HelperMethods extend Grape::API::Helpers def current_user @current_user ||= params[:current_user] end end class Nested < Grape::API resource :level1 do helpers HelperMethods get do current_user end resource :level2 do get do current_user end end end end class Main < Grape::API mount Nested end end subject do NestedHelpersSpec::Main end def app subject end it 'can access helpers from a mounted resource' do get '/level1', current_user: 'hello' expect(last_response.body).to eq('hello') end it 'can access helpers from a mounted resource in a nested resource' do get '/level1/level2', current_user: 'world' expect(last_response.body).to eq('world') end end grape-0.16.2/spec/grape/api/invalid_format_spec.rb0000644000004100000410000000172612706307016022074 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Endpoint do subject { Class.new(Grape::API) } def app subject end before do subject.namespace do format :json content_type :json, 'application/json' params do requires :id, desc: 'Identifier.' end get ':id' do { id: params[:id], format: params[:format] } end end end context 'get' do it 'no format' do get '/foo' expect(last_response.status).to eq 200 expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: nil)) end it 'json format' do get '/foo.json' expect(last_response.status).to eq 200 expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: 'json')) end it 'invalid format' do get '/foo.invalid' expect(last_response.status).to eq 200 expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: 'invalid')) end end end grape-0.16.2/spec/grape/api/shared_helpers_spec.rb0000644000004100000410000000123212706307016022056 0ustar www-datawww-datarequire 'spec_helper' describe Grape::API::Helpers do subject do shared_params = Module.new do extend Grape::API::Helpers params :pagination do optional :page, type: Integer optional :size, type: Integer end end Class.new(Grape::API) do helpers shared_params format :json params do use :pagination end get do declared(params, include_missing: true) end end end def app subject end it 'defines parameters' do get '/' expect(last_response.status).to eq 200 expect(last_response.body).to eq({ page: nil, size: nil }.to_json) end end grape-0.16.2/spec/grape/api/required_parameters_with_invalid_method_spec.rb0000644000004100000410000000060512706307016027235 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Endpoint do subject { Class.new(Grape::API) } def app subject end before do subject.namespace do params do requires :id, desc: 'Identifier.' end get ':id' do end end end context 'post' do it '405' do post '/something' expect(last_response.status).to eq 405 end end end grape-0.16.2/spec/grape/api/namespace_parameters_in_route_spec.rb0000644000004100000410000000122612706307016025154 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Endpoint do subject { Class.new(Grape::API) } def app subject end before do subject.namespace :me do namespace :pending do get '/' do 'banana' end end put ':id' do params[:id] end end end context 'get' do it 'responds without ext' do get '/me/pending' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'banana' end end context 'put' do it 'responds' do put '/me/foo' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'foo' end end end grape-0.16.2/spec/grape/api/custom_validations_spec.rb0000644000004100000410000001252012706307016022777 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations do context 'using a custom length validator' do before do module CustomValidationsSpec class DefaultLength < Grape::Validations::Base def validate_param!(attr_name, params) @option = params[:max].to_i if params.key?(:max) return if params[attr_name].length <= @option fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long" end end end end subject do Class.new(Grape::API) do params do requires :text, default_length: 140 end get do 'bacon' end end end def app subject end it 'under 140 characters' do get '/', text: 'abc' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bacon' end it 'over 140 characters' do get '/', text: 'a' * 141 expect(last_response.status).to eq 400 expect(last_response.body).to eq 'text must be at the most 140 characters long' end it 'specified in the query string' do get '/', text: 'a' * 141, max: 141 expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bacon' end end context 'using a custom body-only validator' do before do module CustomValidationsSpec class InBody < Grape::Validations::PresenceValidator def validate(request) validate!(request.env['api.request.body']) end end end end subject do Class.new(Grape::API) do params do requires :text, in_body: true end get do 'bacon' end end end def app subject end it 'allows field in body' do get '/', text: 'abc' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bacon' end it 'ignores field in query' do get '/', nil, text: 'abc' expect(last_response.status).to eq 400 expect(last_response.body).to eq 'text is missing' end end context 'using a custom validator with message_key' do before do module CustomValidationsSpec class WithMessageKey < Grape::Validations::PresenceValidator def validate_param!(attr_name, _params) fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: :presence end end end end subject do Class.new(Grape::API) do params do requires :text, with_message_key: true end get do 'bacon' end end end def app subject end it 'fails with message' do get '/', text: 'foobar' expect(last_response.status).to eq 400 expect(last_response.body).to eq 'text is missing' end end context 'using a custom request/param validator' do before do module CustomValidationsSpec class Admin < Grape::Validations::Base def validate(request) # return if the param we are checking was not in request # @attrs is a list containing the attribute we are currently validating return unless request.params.key? @attrs.first # check if admin flag is set to true return unless @option # check if user is admin or not # as an example get a token from request and check if it's admin or not fail Grape::Exceptions::Validation, params: @attrs, message: 'Can not set Admin only field.' unless request.headers['X-Access-Token'] == 'admin' end end end end subject do Class.new(Grape::API) do params do optional :admin_field, type: String, admin: true optional :non_admin_field, type: String optional :admin_false_field, type: String, admin: false end get do 'bacon' end end end def app subject end it 'fail when non-admin user sets an admin field' do get '/', admin_field: 'tester', non_admin_field: 'toaster' expect(last_response.status).to eq 400 expect(last_response.body).to include 'Can not set Admin only field.' end it 'does not fail when we send non-admin fields only' do get '/', non_admin_field: 'toaster' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bacon' end it 'does not fail when we send non-admin and admin=false fields only' do get '/', non_admin_field: 'toaster', admin_false_field: 'test' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bacon' end it 'does not fail when we send admin fields and we are admin' do header 'X-Access-Token', 'admin' get '/', admin_field: 'tester', non_admin_field: 'toaster', admin_false_field: 'test' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bacon' end it 'fails when we send admin fields and we are not admin' do header 'X-Access-Token', 'user' get '/', admin_field: 'tester', non_admin_field: 'toaster', admin_false_field: 'test' expect(last_response.status).to eq 400 expect(last_response.body).to include 'Can not set Admin only field.' end end end grape-0.16.2/spec/grape/api/optional_parameters_in_route_spec.rb0000644000004100000410000000146312706307016025050 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Endpoint do subject { Class.new(Grape::API) } def app subject end before do subject.namespace :api do get ':id(/:ext)' do [params[:id], params[:ext]].compact.join('/') end put ':id' do params[:id] end end end context 'get' do it 'responds without ext' do get '/api/foo' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'foo' end it 'responds with ext' do get '/api/foo/bar' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'foo/bar' end end context 'put' do it 'responds' do put '/api/foo' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'foo' end end end grape-0.16.2/spec/grape/api/patch_method_helpers_spec.rb0000644000004100000410000000331112706307016023247 0ustar www-datawww-datarequire 'spec_helper' describe Grape::API::Helpers do module PatchHelpersSpec class PatchPublic < Grape::API format :json version 'public-v1', using: :header, vendor: 'grape' get do { ok: 'public' } end end module AuthMethods def authenticate! end end class PatchPrivate < Grape::API format :json version 'private-v1', using: :header, vendor: 'grape' helpers AuthMethods before do authenticate! end get do { ok: 'private' } end end class Main < Grape::API mount PatchPublic mount PatchPrivate end end def app PatchHelpersSpec::Main end context 'patch' do it 'public' do patch '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-public-v1+json' expect(last_response.status).to eq 405 end it 'private' do patch '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-private-v1+json' expect(last_response.status).to eq 405 end it 'default' do patch '/' expect(last_response.status).to eq 405 end end context 'default' do it 'public' do get '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-public-v1+json' expect(last_response.status).to eq 200 expect(last_response.body).to eq({ ok: 'public' }.to_json) end it 'private' do get '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-private-v1+json' expect(last_response.status).to eq 200 expect(last_response.body).to eq({ ok: 'private' }.to_json) end it 'default' do get '/' expect(last_response.status).to eq 200 expect(last_response.body).to eq({ ok: 'public' }.to_json) end end end grape-0.16.2/spec/grape/api/deeply_included_options_spec.rb0000644000004100000410000000216412706307016023777 0ustar www-datawww-datarequire 'spec_helper' module DeeplyIncludedOptionsSpec module Defaults extend ActiveSupport::Concern included do format :json end end module Admin module Defaults extend ActiveSupport::Concern include DeeplyIncludedOptionsSpec::Defaults end class Users < Grape::API include DeeplyIncludedOptionsSpec::Admin::Defaults resource :users do get do status 200 end end end end class Main < Grape::API mount DeeplyIncludedOptionsSpec::Admin::Users end end describe Grape::API do subject { DeeplyIncludedOptionsSpec::Main } def app subject end it 'works for unspecified format' do get '/users' expect(last_response.status).to eql 200 expect(last_response.content_type).to eql 'application/json' end it 'works for specified format' do get '/users.json' expect(last_response.status).to eql 200 expect(last_response.content_type).to eql 'application/json' end it "doesn't work for format different than specified" do get '/users.txt' expect(last_response.status).to eql 404 end end grape-0.16.2/spec/grape/api/required_parameters_in_route_spec.rb0000644000004100000410000000122612706307016025040 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Endpoint do subject { Class.new(Grape::API) } def app subject end before do subject.namespace :api do get ':id' do [params[:id], params[:ext]].compact.join('/') end put ':something_id' do params[:something_id] end end end context 'get' do it 'responds' do get '/api/foo' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'foo' end end context 'put' do it 'responds' do put '/api/foo' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'foo' end end end grape-0.16.2/spec/grape/api/recognize_path_spec.rb0000644000004100000410000000104712706307016022073 0ustar www-datawww-datarequire 'spec_helper' describe Grape::API do describe '.recognize_path' do subject { Class.new(Grape::API) } it 'fetches endpoint by given path' do subject.get('/foo/:id') {} subject.get('/bar/:id') {} subject.get('/baz/:id') {} actual = subject.recognize_path('/bar/1234').routes[0].origin expect(actual).to eq('/bar/:id') end it 'returns nil if given path does not match with registered routes' do subject.get {} expect(subject.recognize_path('/bar/1234')).to be_nil end end end grape-0.16.2/spec/grape/entity_spec.rb0000644000004100000410000002163312706307016017640 0ustar www-datawww-datarequire 'spec_helper' require 'grape_entity' describe Grape::Entity do subject { Class.new(Grape::API) } def app subject end describe '#present' do it 'sets the object as the body if no options are provided' do inner_body = nil subject.get '/example' do present(abc: 'def') inner_body = body end get '/example' expect(inner_body).to eql(abc: 'def') end it 'calls through to the provided entity class if one is given' do entity_mock = Object.new allow(entity_mock).to receive(:represent) subject.get '/example' do present Object.new, with: entity_mock end get '/example' end it 'pulls a representation from the class options if it exists' do entity = Class.new(Grape::Entity) allow(entity).to receive(:represent).and_return('Hiya') subject.represent Object, with: entity subject.get '/example' do present Object.new end get '/example' expect(last_response.body).to eq('Hiya') end it 'pulls a representation from the class options if the presented object is a collection of objects' do entity = Class.new(Grape::Entity) allow(entity).to receive(:represent).and_return('Hiya') module EntitySpec class TestObject end class FakeCollection def first TestObject.new end end end subject.represent EntitySpec::TestObject, with: entity subject.get '/example' do present [EntitySpec::TestObject.new] end subject.get '/example2' do present EntitySpec::FakeCollection.new end get '/example' expect(last_response.body).to eq('Hiya') get '/example2' expect(last_response.body).to eq('Hiya') end it 'pulls a representation from the class ancestor if it exists' do entity = Class.new(Grape::Entity) allow(entity).to receive(:represent).and_return('Hiya') subclass = Class.new(Object) subject.represent Object, with: entity subject.get '/example' do present subclass.new end get '/example' expect(last_response.body).to eq('Hiya') end it 'automatically uses Klass::Entity if that exists' do some_model = Class.new entity = Class.new(Grape::Entity) allow(entity).to receive(:represent).and_return('Auto-detect!') some_model.const_set :Entity, entity subject.get '/example' do present some_model.new end get '/example' expect(last_response.body).to eq('Auto-detect!') end it 'automatically uses Klass::Entity based on the first object in the collection being presented' do some_model = Class.new entity = Class.new(Grape::Entity) allow(entity).to receive(:represent).and_return('Auto-detect!') some_model.const_set :Entity, entity subject.get '/example' do present [some_model.new] end get '/example' expect(last_response.body).to eq('Auto-detect!') end it 'does not run autodetection for Entity when explicitely provided' do entity = Class.new(Grape::Entity) some_array = [] subject.get '/example' do present some_array, with: entity end expect(some_array).not_to receive(:first) get '/example' end it 'does not use #first method on ActiveRecord::Relation to prevent needless sql query' do entity = Class.new(Grape::Entity) some_relation = Class.new some_model = Class.new allow(entity).to receive(:represent).and_return('Auto-detect!') allow(some_relation).to receive(:first) allow(some_relation).to receive(:klass).and_return(some_model) some_model.const_set :Entity, entity subject.get '/example' do present some_relation end expect(some_relation).not_to receive(:first) get '/example' expect(last_response.body).to eq('Auto-detect!') end it 'autodetection does not use Entity if it is not a presenter' do some_model = Class.new entity = Class.new some_model.class.const_set :Entity, entity subject.get '/example' do present some_model end get '/example' expect(entity).not_to receive(:represent) end it 'adds a root key to the output if one is given' do inner_body = nil subject.get '/example' do present({ abc: 'def' }, root: :root) inner_body = body end get '/example' expect(inner_body).to eql(root: { abc: 'def' }) end [:json, :serializable_hash].each do |format| it "presents with #{format}" do entity = Class.new(Grape::Entity) entity.root 'examples', 'example' entity.expose :id subject.format format subject.get '/example' do c = Class.new do attr_reader :id def initialize(id) @id = id end end present c.new(1), with: entity end get '/example' expect(last_response.status).to eq(200) expect(last_response.body).to eq('{"example":{"id":1}}') end it "presents with #{format} collection" do entity = Class.new(Grape::Entity) entity.root 'examples', 'example' entity.expose :id subject.format format subject.get '/examples' do c = Class.new do attr_reader :id def initialize(id) @id = id end end examples = [c.new(1), c.new(2)] present examples, with: entity end get '/examples' expect(last_response.status).to eq(200) expect(last_response.body).to eq('{"examples":[{"id":1},{"id":2}]}') end end it 'presents with xml' do entity = Class.new(Grape::Entity) entity.root 'examples', 'example' entity.expose :name subject.format :xml subject.get '/example' do c = Class.new do attr_reader :name def initialize(args) @name = args[:name] || 'no name set' end end present c.new(name: 'johnnyiller'), with: entity end get '/example' expect(last_response.status).to eq(200) expect(last_response.headers['Content-type']).to eq('application/xml') expect(last_response.body).to eq <<-XML johnnyiller XML end it 'presents with json' do entity = Class.new(Grape::Entity) entity.root 'examples', 'example' entity.expose :name subject.format :json subject.get '/example' do c = Class.new do attr_reader :name def initialize(args) @name = args[:name] || 'no name set' end end present c.new(name: 'johnnyiller'), with: entity end get '/example' expect(last_response.status).to eq(200) expect(last_response.headers['Content-type']).to eq('application/json') expect(last_response.body).to eq('{"example":{"name":"johnnyiller"}}') end it 'presents with jsonp utilising Rack::JSONP' do require 'rack/contrib' # Include JSONP middleware subject.use Rack::JSONP entity = Class.new(Grape::Entity) entity.root 'examples', 'example' entity.expose :name # Rack::JSONP expects a standard JSON response in UTF-8 format subject.format :json subject.formatter :json, lambda { |object, _| object.to_json.encode('utf-8') } subject.get '/example' do c = Class.new do attr_reader :name def initialize(args) @name = args[:name] || 'no name set' end end present c.new(name: 'johnnyiller'), with: entity end get '/example?callback=abcDef' expect(last_response.status).to eq(200) expect(last_response.headers['Content-type']).to eq('application/javascript') expect(last_response.body).to include 'abcDef({"example":{"name":"johnnyiller"}})' end context 'present with multiple entities' do it 'present with multiple entities using optional symbol' do user = Class.new do attr_reader :name def initialize(args) @name = args[:name] || 'no name set' end end user1 = user.new(name: 'user1') user2 = user.new(name: 'user2') entity = Class.new(Grape::Entity) entity.expose :name subject.format :json subject.get '/example' do present :page, 1 present :user1, user1, with: entity present :user2, user2, with: entity end get '/example' expect_response_json = { 'page' => 1, 'user1' => { 'name' => 'user1' }, 'user2' => { 'name' => 'user2' } } expect(JSON(last_response.body)).to eq(expect_response_json) end end end end grape-0.16.2/spec/grape/api_spec.rb0000644000004100000410000026242312706307016017101 0ustar www-datawww-datarequire 'spec_helper' require 'shared/versioning_examples' require 'grape-entity' describe Grape::API do subject { Class.new(Grape::API) } def app subject end describe '.prefix' do it 'routes root through with the prefix' do subject.prefix 'awesome/sauce' subject.get do 'Hello there.' end get 'awesome/sauce/' expect(last_response.status).to eql 200 expect(last_response.body).to eql 'Hello there.' end it 'routes through with the prefix' do subject.prefix 'awesome/sauce' subject.get :hello do 'Hello there.' end get 'awesome/sauce/hello' expect(last_response.body).to eql 'Hello there.' get '/hello' expect(last_response.status).to eql 404 end it 'supports OPTIONS' do subject.prefix 'awesome/sauce' subject.get do 'Hello there.' end options 'awesome/sauce' expect(last_response.status).to eql 204 expect(last_response.body).to be_blank end it 'disallows POST' do subject.prefix 'awesome/sauce' subject.get post 'awesome/sauce' expect(last_response.status).to eql 405 end end describe '.version' do context 'when defined' do it 'returns version value' do subject.version 'v1' expect(subject.version).to eq('v1') end end context 'when not defined' do it 'returns nil' do expect(subject.version).to be_nil end end end describe '.version using path' do it_should_behave_like 'versioning' do let(:macro_options) do { using: :path } end end end describe '.version using param' do it_should_behave_like 'versioning' do let(:macro_options) do { using: :param, parameter: 'apiver' } end end end describe '.version using header' do it_should_behave_like 'versioning' do let(:macro_options) do { using: :header, vendor: 'mycompany', format: 'json' } end end # Behavior as defined by rfc2616 when no header is defined # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html describe 'no specified accept header' do # subject.version 'v1', using: :header # subject.get '/hello' do # 'hello' # end # it 'routes' do # get '/hello' # last_response.status.should eql 200 # end end # pending 'routes if any media type is allowed' end describe '.version using accept_version_header' do it_should_behave_like 'versioning' do let(:macro_options) do { using: :accept_version_header } end end end describe '.represent' do it 'requires a :with option' do expect { subject.represent Object, {} }.to raise_error(Grape::Exceptions::InvalidWithOptionForRepresent) end it 'adds the association to the :representations setting' do klass = Class.new subject.represent Object, with: klass expect(subject.namespace_stackable_with_hash(:representations)[Object]).to eq(klass) end end describe '.namespace' do it 'is retrievable and converted to a path' do internal_namespace = nil subject.namespace :awesome do internal_namespace = namespace end expect(internal_namespace).to eql('/awesome') end it 'comes after the prefix and version' do subject.prefix :rad subject.version 'v1', using: :path subject.namespace :awesome do get('/hello') { 'worked' } end get '/rad/v1/awesome/hello' expect(last_response.body).to eq('worked') end it 'cancels itself after the block is over' do internal_namespace = nil subject.namespace :awesome do internal_namespace = namespace end expect(subject.namespace).to eql('/') end it 'is stackable' do internal_namespace = nil internal_second_namespace = nil subject.namespace :awesome do internal_namespace = namespace namespace :rad do internal_second_namespace = namespace end end expect(internal_namespace).to eq('/awesome') expect(internal_second_namespace).to eq('/awesome/rad') end it 'accepts path segments correctly' do inner_namespace = nil subject.namespace :members do namespace '/:member_id' do inner_namespace = namespace get '/' do params[:member_id] end end end get '/members/23' expect(last_response.body).to eq('23') expect(inner_namespace).to eq('/members/:member_id') end it 'is callable with nil just to push onto the stack' do subject.namespace do version 'v2', using: :path get('/hello') { 'inner' } end subject.get('/hello') { 'outer' } get '/v2/hello' expect(last_response.body).to eq('inner') get '/hello' expect(last_response.body).to eq('outer') end %w(group resource resources segment).each do |als| it "`.#{als}` is an alias" do inner_namespace = nil subject.send(als, :awesome) do inner_namespace = namespace end expect(inner_namespace).to eq '/awesome' end end end describe '.route_param' do it 'adds a parameterized route segment namespace' do subject.namespace :users do route_param :id do get do params[:id] end end end get '/users/23' expect(last_response.body).to eq('23') end it 'defines requirements with a single hash' do subject.namespace :users do route_param :id, requirements: /[0-9]+/ do get do params[:id] end end end get '/users/michael' expect(last_response.status).to eq(404) get '/users/23' expect(last_response.status).to eq(200) end context 'with param type definitions' do it 'is used by passing to options' do subject.namespace :route_param do route_param :foo, type: Integer do get { params.to_json } end end get '/route_param/1234' expect(last_response.body).to eq("{\"foo\":1234}") end end end describe '.route' do it 'allows for no path' do subject.namespace :votes do get do 'Votes' end post do 'Created a Vote' end end get '/votes' expect(last_response.body).to eql 'Votes' post '/votes' expect(last_response.body).to eql 'Created a Vote' end it 'handles empty calls' do subject.get '/' get '/' expect(last_response.body).to eql '' end describe 'root routes should work with' do before do subject.format :txt subject.content_type :json, 'application/json' subject.formatter :json, ->(object, _env) { object } def subject.enable_root_route! get('/') { 'root' } end end after do expect(last_response.body).to eql 'root' end describe 'path versioned APIs' do before do subject.version 'v1', using: :path subject.enable_root_route! end it 'without a format' do versioned_get '/', 'v1', using: :path end it 'with a format' do get '/v1/.json' end end it 'header versioned APIs' do subject.version 'v1', using: :header, vendor: 'test' subject.enable_root_route! versioned_get '/', 'v1', using: :header, vendor: 'test' end it 'header versioned APIs with multiple headers' do subject.version %w(v1 v2), using: :header, vendor: 'test' subject.enable_root_route! versioned_get '/', 'v1', using: :header, vendor: 'test' versioned_get '/', 'v2', using: :header, vendor: 'test' end it 'param versioned APIs' do subject.version 'v1', using: :param subject.enable_root_route! versioned_get '/', 'v1', using: :param end it 'Accept-Version header versioned APIs' do subject.version 'v1', using: :accept_version_header subject.enable_root_route! versioned_get '/', 'v1', using: :accept_version_header end it 'unversioned APIs' do subject.enable_root_route! get '/' end end it 'allows for multiple paths' do subject.get(['/abc', '/def']) do 'foo' end get '/abc' expect(last_response.body).to eql 'foo' get '/def' expect(last_response.body).to eql 'foo' end context 'format' do before(:each) do allow_any_instance_of(Object).to receive(:to_json).and_return('abc') allow_any_instance_of(Object).to receive(:to_txt).and_return('def') subject.get('/abc') do Object.new end end it 'allows .json' do get '/abc.json' expect(last_response.status).to eq(200) expect(last_response.body).to eql 'abc' # json-encoded symbol end it 'allows .txt' do get '/abc.txt' expect(last_response.status).to eq(200) expect(last_response.body).to eql 'def' # raw text end end it 'allows for format without corrupting a param' do subject.get('/:id') do { 'id' => params[:id] } end get '/awesome.json' expect(last_response.body).to eql '{"id":"awesome"}' end it 'allows for format in namespace with no path' do subject.namespace :abc do get do ['json'] end end get '/abc.json' expect(last_response.body).to eql '["json"]' end it 'allows for multiple verbs' do subject.route([:get, :post], '/abc') do 'hiya' end subject.endpoints.first.routes.each do |route| expect(route.path).to eql '/abc(.:format)' end get '/abc' expect(last_response.body).to eql 'hiya' post '/abc' expect(last_response.body).to eql 'hiya' end [:put, :post].each do |verb| context verb do ['string', :symbol, 1, -1.1, {}, [], true, false, nil].each do |object| it "allows a(n) #{object.class} json object in params" do subject.format :json subject.send(verb) do env['api.request.body'] end send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(verb == :post ? 201 : 200) expect(last_response.body).to eql MultiJson.dump(object) expect(last_request.params).to eql({}) end it 'stores input in api.request.input' do subject.format :json subject.send(verb) do env['api.request.input'] end send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(verb == :post ? 201 : 200) expect(last_response.body).to eql MultiJson.dump(object).to_json end context 'chunked transfer encoding' do it 'stores input in api.request.input' do subject.format :json subject.send(verb) do env['api.request.input'] end send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json', 'HTTP_TRANSFER_ENCODING' => 'chunked', 'CONTENT_LENGTH' => nil expect(last_response.status).to eq(verb == :post ? 201 : 200) expect(last_response.body).to eql MultiJson.dump(object).to_json end end end end end it 'allows for multipart paths' do subject.route([:get, :post], '/:id/first') do 'first' end subject.route([:get, :post], '/:id') do 'ola' end subject.route([:get, :post], '/:id/first/second') do 'second' end get '/1' expect(last_response.body).to eql 'ola' post '/1' expect(last_response.body).to eql 'ola' get '/1/first' expect(last_response.body).to eql 'first' post '/1/first' expect(last_response.body).to eql 'first' get '/1/first/second' expect(last_response.body).to eql 'second' end it 'allows for :any as a verb' do subject.route(:any, '/abc') do 'lol' end %w(get post put delete options patch).each do |m| send(m, '/abc') expect(last_response.body).to eql 'lol' end end verbs = %w(post get head delete put options patch) verbs.each do |verb| it "allows and properly constrain a #{verb.upcase} method" do subject.send(verb, '/example') do verb end send(verb, '/example') expect(last_response.body).to eql verb == 'head' ? '' : verb # Call it with a method other than the properly constrained one. send(used_verb = verbs[(verbs.index(verb) + 2) % verbs.size], '/example') expect(last_response.status).to eql used_verb == 'options' ? 204 : 405 end end it 'returns a 201 response code for POST by default' do subject.post('example') do 'Created' end post '/example' expect(last_response.status).to eql 201 expect(last_response.body).to eql 'Created' end it 'returns a 405 for an unsupported method with an X-Custom-Header' do subject.before { header 'X-Custom-Header', 'foo' } subject.get 'example' do 'example' end put '/example' expect(last_response.status).to eql 405 expect(last_response.body).to eql '405 Not Allowed' expect(last_response.headers['X-Custom-Header']).to eql 'foo' end context 'when format is xml' do it 'returns a 405 for an unsupported method' do subject.format :xml subject.get 'example' do 'example' end put '/example' expect(last_response.status).to eql 405 expect(last_response.body).to eq <<-XML 405 Not Allowed XML end end specify '405 responses includes an Allow header specifying supported methods' do subject.get 'example' do 'example' end subject.post 'example' do 'example' end put '/example' expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, POST, HEAD' end specify '405 responses includes an Content-Type header' do subject.get 'example' do 'example' end subject.post 'example' do 'example' end put '/example' expect(last_response.headers['Content-Type']).to eql 'text/plain' end describe 'adds an OPTIONS route that' do before do subject.before { header 'X-Custom-Header', 'foo' } subject.get 'example' do 'example' end subject.route :any, '*path' do error! :not_found, 404 end options '/example' end it 'returns a 204' do expect(last_response.status).to eql 204 end it 'has an empty body' do expect(last_response.body).to be_blank end it 'has an Allow header' do expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD' end it 'has a X-Custom-Header' do expect(last_response.headers['X-Custom-Header']).to eql 'foo' end it 'has no Content-Type' do expect(last_response.content_type).to be_nil end it 'has no Content-Length' do expect(last_response.content_length).to be_nil end end describe 'adds a 405 Not Allowed route that' do before do subject.before { header 'X-Custom-Header', 'foo' } subject.post :example do 'example' end subject.route :any, '*path' do error! :not_found, 404 end get '/example' end it 'returns a 405' do expect(last_response.status).to eql 405 end it 'contains error message in body' do expect(last_response.body).to eq '405 Not Allowed' end it 'has an Allow header' do expect(last_response.headers['Allow']).to eql 'OPTIONS, POST' end it 'has a X-Custom-Header' do expect(last_response.headers['X-Custom-Header']).to eql 'foo' end end context 'allows HEAD on a GET request that' do before do subject.get 'example' do 'example' end subject.route :any, '*path' do error! :not_found, 404 end head '/example' end it 'returns a 200' do expect(last_response.status).to eql 200 end it 'has an empty body' do expect(last_response.body).to eql '' end end it 'overwrites the default HEAD request' do subject.head 'example' do error! 'nothing to see here', 400 end subject.get 'example' do 'example' end head '/example' expect(last_response.status).to eql 400 end end context 'do_not_route_head!' do before :each do subject.do_not_route_head! subject.get 'example' do 'example' end end it 'options does not contain HEAD' do options '/example' expect(last_response.status).to eql 204 expect(last_response.body).to eql '' expect(last_response.headers['Allow']).to eql 'OPTIONS, GET' end it 'does not allow HEAD on a GET request' do head '/example' expect(last_response.status).to eql 405 end end context 'do_not_route_options!' do before :each do subject.do_not_route_options! subject.get 'example' do 'example' end end it 'does not create an OPTIONS route' do options '/example' expect(last_response.status).to eql 405 end it 'does not include OPTIONS in Allow header' do options '/example' expect(last_response.status).to eql 405 expect(last_response.headers['Allow']).to eql 'GET, HEAD' end end describe 'filters' do it 'adds a before filter' do subject.before { @foo = 'first' } subject.before { @bar = 'second' } subject.get '/' do "#{@foo} #{@bar}" end get '/' expect(last_response.body).to eql 'first second' end it 'adds a before filter to current and child namespaces only' do subject.get '/' do "root - #{@foo}" end subject.namespace :blah do before { @foo = 'foo' } get '/' do "blah - #{@foo}" end namespace :bar do get '/' do "blah - bar - #{@foo}" end end end get '/' expect(last_response.body).to eql 'root - ' get '/blah' expect(last_response.body).to eql 'blah - foo' get '/blah/bar' expect(last_response.body).to eql 'blah - bar - foo' end it 'adds a after_validation filter' do subject.after_validation { @foo = "first #{params[:id]}:#{params[:id].class}" } subject.after_validation { @bar = 'second' } subject.params do requires :id, type: Integer end subject.get '/' do "#{@foo} #{@bar}" end get '/', id: '32' expect(last_response.body).to eql 'first 32:Fixnum second' end it 'adds a after filter' do m = double('after mock') subject.after { m.do_something! } subject.after { m.do_something! } subject.get '/' do @var ||= 'default' end expect(m).to receive(:do_something!).exactly(2).times get '/' expect(last_response.body).to eql 'default' end it 'calls all filters when validation passes' do a = double('before mock') b = double('before_validation mock') c = double('after_validation mock') d = double('after mock') subject.params do requires :id, type: Integer end subject.resource ':id' do before { a.do_something! } before_validation { b.do_something! } after_validation { c.do_something! } after { d.do_something! } get do 'got it' end end expect(a).to receive(:do_something!).exactly(1).times expect(b).to receive(:do_something!).exactly(1).times expect(c).to receive(:do_something!).exactly(1).times expect(d).to receive(:do_something!).exactly(1).times get '/123' expect(last_response.status).to eql 200 expect(last_response.body).to eql 'got it' end it 'calls only before filters when validation fails' do a = double('before mock') b = double('before_validation mock') c = double('after_validation mock') d = double('after mock') subject.params do requires :id, type: Integer end subject.resource ':id' do before { a.do_something! } before_validation { b.do_something! } after_validation { c.do_something! } after { d.do_something! } get do 'got it' end end expect(a).to receive(:do_something!).exactly(1).times expect(b).to receive(:do_something!).exactly(1).times expect(c).to receive(:do_something!).exactly(0).times expect(d).to receive(:do_something!).exactly(0).times get '/abc' expect(last_response.status).to eql 400 expect(last_response.body).to eql 'id is invalid' end it 'calls filters in the correct order' do i = 0 a = double('before mock') b = double('before_validation mock') c = double('after_validation mock') d = double('after mock') subject.params do requires :id, type: Integer end subject.resource ':id' do before { a.here(i += 1) } before_validation { b.here(i += 1) } after_validation { c.here(i += 1) } after { d.here(i += 1) } get do 'got it' end end expect(a).to receive(:here).with(1).exactly(1).times expect(b).to receive(:here).with(2).exactly(1).times expect(c).to receive(:here).with(3).exactly(1).times expect(d).to receive(:here).with(4).exactly(1).times get '/123' expect(last_response.status).to eql 200 expect(last_response.body).to eql 'got it' end end context 'format' do before do subject.get('/foo') { 'bar' } end it 'sets content type for txt format' do get '/foo' expect(last_response.headers['Content-Type']).to eq('text/plain') end it 'sets content type for xml' do get '/foo.xml' expect(last_response.headers['Content-Type']).to eq('application/xml') end it 'sets content type for json' do get '/foo.json' expect(last_response.headers['Content-Type']).to eq('application/json') end it 'sets content type for serializable hash format' do get '/foo.serializable_hash' expect(last_response.headers['Content-Type']).to eq('application/json') end it 'sets content type for binary format' do get '/foo.binary' expect(last_response.headers['Content-Type']).to eq('application/octet-stream') end it 'returns raw data when content type binary' do image_filename = 'grape.png' file = File.open(image_filename, 'rb', &:read) subject.format :binary subject.get('/binary_file') { File.binread(image_filename) } get '/binary_file' expect(last_response.headers['Content-Type']).to eq('application/octet-stream') expect(last_response.body).to eq(file) end it 'returns the content of the file with file' do file_content = 'This is some file content' test_file = Tempfile.new('test') test_file.write file_content test_file.rewind subject.get('/file') { file test_file } get '/file' expect(last_response.headers['Content-Length']).to eq('25') expect(last_response.headers['Content-Type']).to eq('text/plain') expect(last_response.body).to eq(file_content) end it 'streams the content of the file with stream' do test_stream = Enumerator.new do |blk| blk.yield 'This is some' blk.yield ' file content' end subject.use Rack::Chunked subject.get('/stream') { stream test_stream } get '/stream', {}, 'HTTP_VERSION' => 'HTTP/1.1' expect(last_response.headers['Content-Type']).to eq('text/plain') expect(last_response.headers['Content-Length']).to eq(nil) expect(last_response.headers['Cache-Control']).to eq('no-cache') expect(last_response.headers['Transfer-Encoding']).to eq('chunked') expect(last_response.body).to eq("c\r\nThis is some\r\nd\r\n file content\r\n0\r\n\r\n") end it 'sets content type for error' do subject.get('/error') { error!('error in plain text', 500) } get '/error' expect(last_response.headers['Content-Type']).to eql 'text/plain' end it 'sets content type for json error' do subject.format :json subject.get('/error') { error!('error in json', 500) } get '/error.json' expect(last_response.status).to eql 500 expect(last_response.headers['Content-Type']).to eql 'application/json' end it 'sets content type for xml error' do subject.format :xml subject.get('/error') { error!('error in xml', 500) } get '/error' expect(last_response.status).to eql 500 expect(last_response.headers['Content-Type']).to eql 'application/xml' end it 'includes extension in format' do subject.get(':id') { params[:format] } get '/baz.bar' expect(last_response.status).to eq 200 expect(last_response.body).to eq 'bar' end it 'does not include extension in id' do subject.format :json subject.get(':id') { params } get '/baz.bar' expect(last_response.status).to eq 404 end context 'with a custom content_type' do before do subject.content_type :custom, 'application/custom' subject.formatter :custom, ->(_object, _env) { 'custom' } subject.get('/custom') { 'bar' } subject.get('/error') { error!('error in custom', 500) } end it 'sets content type' do get '/custom.custom' expect(last_response.headers['Content-Type']).to eql 'application/custom' end it 'sets content type for error' do get '/error.custom' expect(last_response.headers['Content-Type']).to eql 'application/custom' end end context 'env["api.format"]' do before do subject.post 'attachment' do filename = params[:file][:filename] content_type MIME::Types.type_for(filename)[0].to_s env['api.format'] = :binary # there's no formatter for :binary, data will be returned "as is" header 'Content-Disposition', "attachment; filename*=UTF-8''#{CGI.escape(filename)}" params[:file][:tempfile].read end end ['/attachment.png', 'attachment'].each do |url| it "uploads and downloads a PNG file via #{url}" do image_filename = 'grape.png' post url, file: Rack::Test::UploadedFile.new(image_filename, 'image/png', true) expect(last_response.status).to eq(201) expect(last_response.headers['Content-Type']).to eq('image/png') expect(last_response.headers['Content-Disposition']).to eq("attachment; filename*=UTF-8''grape.png") File.open(image_filename, 'rb') do |io| expect(last_response.body).to eq io.read end end end it 'uploads and downloads a Ruby file' do filename = __FILE__ post '/attachment.rb', file: Rack::Test::UploadedFile.new(filename, 'application/x-ruby', true) expect(last_response.status).to eq(201) expect(last_response.headers['Content-Type']).to eq('application/x-ruby') expect(last_response.headers['Content-Disposition']).to eq("attachment; filename*=UTF-8''api_spec.rb") File.open(filename, 'rb') do |io| expect(last_response.body).to eq io.read end end end end context 'custom middleware' do module ApiSpec class PhonyMiddleware def initialize(app, *args) @args = args @app = app @block = true if block_given? end def call(env) env['phony.args'] ||= [] env['phony.args'] << @args env['phony.block'] = true if @block @app.call(env) end end end describe '.middleware' do it 'includes middleware arguments from settings' do subject.use ApiSpec::PhonyMiddleware, 'abc', 123 expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, 'abc', 123]] end it 'includes all middleware from stacked settings' do subject.use ApiSpec::PhonyMiddleware, 123 subject.use ApiSpec::PhonyMiddleware, 'abc' subject.use ApiSpec::PhonyMiddleware, 'foo' expect(subject.middleware).to eql [ [ApiSpec::PhonyMiddleware, 123], [ApiSpec::PhonyMiddleware, 'abc'], [ApiSpec::PhonyMiddleware, 'foo'] ] end end describe '.use' do it 'adds middleware' do subject.use ApiSpec::PhonyMiddleware, 123 expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, 123]] end it 'does not show up outside the namespace' do inner_middleware = nil subject.use ApiSpec::PhonyMiddleware, 123 subject.namespace :awesome do use ApiSpec::PhonyMiddleware, 'abc' inner_middleware = middleware end expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, 123]] expect(inner_middleware).to eql [[ApiSpec::PhonyMiddleware, 123], [ApiSpec::PhonyMiddleware, 'abc']] end it 'calls the middleware' do subject.use ApiSpec::PhonyMiddleware, 'hello' subject.get '/' do env['phony.args'].first.first end get '/' expect(last_response.body).to eql 'hello' end it 'adds a block if one is given' do block = -> {} subject.use ApiSpec::PhonyMiddleware, &block expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, block]] end it 'uses a block if one is given' do block = -> {} subject.use ApiSpec::PhonyMiddleware, &block subject.get '/' do env['phony.block'].inspect end get '/' expect(last_response.body).to eq('true') end it 'does not destroy the middleware settings on multiple runs' do block = -> {} subject.use ApiSpec::PhonyMiddleware, &block subject.get '/' do env['phony.block'].inspect end 2.times do get '/' expect(last_response.body).to eq('true') end end it 'mounts behind error middleware' do m = Class.new(Grape::Middleware::Base) do def before throw :error, message: 'Caught in the Net', status: 400 end end subject.use m subject.get '/' do end get '/' expect(last_response.status).to eq(400) expect(last_response.body).to eq('Caught in the Net') end end end describe '.http_basic' do it 'protects any resources on the same scope' do subject.http_basic do |u, _p| u == 'allow' end subject.get(:hello) { 'Hello, world.' } get '/hello' expect(last_response.status).to eql 401 get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever') expect(last_response.status).to eql 200 end it 'is scopable' do subject.get(:hello) { 'Hello, world.' } subject.namespace :admin do http_basic do |u, _p| u == 'allow' end get(:hello) { 'Hello, world.' } end get '/hello' expect(last_response.status).to eql 200 get '/admin/hello' expect(last_response.status).to eql 401 end it 'is callable via .auth as well' do subject.auth :http_basic do |u, _p| u == 'allow' end subject.get(:hello) { 'Hello, world.' } get '/hello' expect(last_response.status).to eql 401 get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever') expect(last_response.status).to eql 200 end it 'has access to the current endpoint' do basic_auth_context = nil subject.http_basic do |u, _p| basic_auth_context = self u == 'allow' end subject.get(:hello) { 'Hello, world.' } get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever') expect(basic_auth_context).to be_a_kind_of(Grape::Endpoint) end it 'has access to helper methods' do subject.helpers do def authorize(u, p) u == 'allow' && p == 'whatever' end end subject.http_basic do |u, p| authorize(u, p) end subject.get(:hello) { 'Hello, world.' } get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever') expect(last_response.status).to eql 200 get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('disallow', 'whatever') expect(last_response.status).to eql 401 end it 'can set instance variables accessible to routes' do subject.http_basic do |u, _p| @hello = 'Hello, world.' u == 'allow' end subject.get(:hello) { @hello } get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever') expect(last_response.status).to eql 200 expect(last_response.body).to eql 'Hello, world.' end end describe '.logger' do subject do Class.new(Grape::API) do def self.io @io ||= StringIO.new end logger ::Logger.new(io) end end it 'returns an instance of Logger class by default' do expect(subject.logger.class).to eql Logger end it 'allows setting a custom logger' do mylogger = Class.new subject.logger mylogger expect(mylogger).to receive(:info).exactly(1).times subject.logger.info 'this will be logged' end it 'defaults to a standard logger log format' do t = Time.at(100) allow(Time).to receive(:now).and_return(t) expect(subject.io).to receive(:write).with("I, [#{Logger::Formatter.new.send(:format_datetime, t)}\##{Process.pid}] INFO -- : this will be logged\n") subject.logger.info 'this will be logged' end end describe '.helpers' do it 'is accessible from the endpoint' do subject.helpers do def hello 'Hello, world.' end end subject.get '/howdy' do hello end get '/howdy' expect(last_response.body).to eql 'Hello, world.' end it 'is scopable' do subject.helpers do def generic 'always there' end end subject.namespace :admin do helpers do def secret 'only in admin' end end get '/secret' do [generic, secret].join ':' end end subject.get '/generic' do [generic, respond_to?(:secret)].join ':' end get '/generic' expect(last_response.body).to eql 'always there:false' get '/admin/secret' expect(last_response.body).to eql 'always there:only in admin' end it 'is reopenable' do subject.helpers do def one 1 end end subject.helpers do def two 2 end end subject.get 'howdy' do [one, two] end expect { get '/howdy' }.not_to raise_error end it 'allows for modules' do mod = Module.new do def hello 'Hello, world.' end end subject.helpers mod subject.get '/howdy' do hello end get '/howdy' expect(last_response.body).to eql 'Hello, world.' end it 'allows multiple calls with modules and blocks' do subject.helpers Module.new do def one 1 end end subject.helpers Module.new do def two 2 end end subject.helpers do def three 3 end end subject.get 'howdy' do [one, two, three] end expect { get '/howdy' }.not_to raise_error end end describe '.scope' do # TODO: refactor this to not be tied to versioning. How about a generic # .setting macro? it 'scopes the various settings' do subject.prefix 'new' subject.scope :legacy do prefix 'legacy' get '/abc' do 'abc' end end subject.get '/def' do 'def' end get '/new/abc' expect(last_response.status).to eql 404 get '/legacy/abc' expect(last_response.status).to eql 200 get '/legacy/def' expect(last_response.status).to eql 404 get '/new/def' expect(last_response.status).to eql 200 end end describe '.rescue_from' do it 'does not rescue errors when rescue_from is not set' do subject.get '/exception' do fail 'rain!' end expect { get '/exception' }.to raise_error(RuntimeError, 'rain!') end it 'uses custom helpers defined by using #helpers method' do subject.helpers do def custom_error!(name) error! "hello #{name}" end end subject.rescue_from(ArgumentError) { custom_error! :bob } subject.get '/custom_error' do fail ArgumentError end get '/custom_error' expect(last_response.body).to eq 'hello bob' end it 'rescues all errors if rescue_from :all is called' do subject.rescue_from :all subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.status).to eql 500 expect(last_response.body).to eq 'rain!' end it 'rescues all errors with a json formatter' do subject.format :json subject.default_format :json subject.rescue_from :all subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.status).to eql 500 expect(last_response.body).to eq({ error: 'rain!' }.to_json) end it 'rescues only certain errors if rescue_from is called with specific errors' do subject.rescue_from ArgumentError subject.get('/rescued') { fail ArgumentError } subject.get('/unrescued') { fail 'beefcake' } get '/rescued' expect(last_response.status).to eql 500 expect { get '/unrescued' }.to raise_error(RuntimeError, 'beefcake') end context 'CustomError subclass of Grape::Exceptions::Base' do before do module ApiSpec class CustomError < Grape::Exceptions::Base; end end end it 'does not re-raise exceptions of type Grape::Exceptions::Base' do subject.get('/custom_exception') { fail ApiSpec::CustomError } expect { get '/custom_exception' }.not_to raise_error end it 'rescues custom grape exceptions' do subject.rescue_from ApiSpec::CustomError do |e| rack_response('New Error', e.status) end subject.get '/custom_error' do fail ApiSpec::CustomError, status: 400, message: 'Custom Error' end get '/custom_error' expect(last_response.status).to eq(400) expect(last_response.body).to eq('New Error') end end it 'can rescue exceptions raised in the formatter' do formatter = double(:formatter) allow(formatter).to receive(:call) { fail StandardError } allow(Grape::Formatter).to receive(:formatter_for) { formatter } subject.rescue_from :all do |_e| rack_response('Formatter Error', 500) end subject.get('/formatter_exception') { 'Hello world' } get '/formatter_exception' expect(last_response.status).to eql 500 expect(last_response.body).to eq('Formatter Error') end end describe '.rescue_from klass, block' do it 'rescues Exception' do subject.rescue_from RuntimeError do |e| rack_response("rescued from #{e.message}", 202) end subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.status).to eql 202 expect(last_response.body).to eq('rescued from rain!') end context 'custom errors' do before do class ConnectionError < RuntimeError; end class DatabaseError < RuntimeError; end class CommunicationError < StandardError; end end it 'rescues an error via rescue_from :all' do subject.rescue_from :all do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/exception' do fail ConnectionError end get '/exception' expect(last_response.status).to eql 500 expect(last_response.body).to eq('rescued from ConnectionError') end it 'rescues a specific error' do subject.rescue_from ConnectionError do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/exception' do fail ConnectionError end get '/exception' expect(last_response.status).to eql 500 expect(last_response.body).to eq('rescued from ConnectionError') end it 'rescues a subclass of an error by default' do subject.rescue_from RuntimeError do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/exception' do fail ConnectionError end get '/exception' expect(last_response.status).to eql 500 expect(last_response.body).to eq('rescued from ConnectionError') end it 'rescues multiple specific errors' do subject.rescue_from ConnectionError do |e| rack_response("rescued from #{e.class.name}", 500) end subject.rescue_from DatabaseError do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/connection' do fail ConnectionError end subject.get '/database' do fail DatabaseError end get '/connection' expect(last_response.status).to eql 500 expect(last_response.body).to eq('rescued from ConnectionError') get '/database' expect(last_response.status).to eql 500 expect(last_response.body).to eq('rescued from DatabaseError') end it 'does not rescue a different error' do subject.rescue_from RuntimeError do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/uncaught' do fail CommunicationError end expect { get '/uncaught' }.to raise_error(CommunicationError) end end end describe '.rescue_from klass, lambda' do it 'rescues an error with the lambda' do subject.rescue_from ArgumentError, lambda { rack_response('rescued with a lambda', 400) } subject.get('/rescue_lambda') { fail ArgumentError } get '/rescue_lambda' expect(last_response.status).to eq(400) expect(last_response.body).to eq('rescued with a lambda') end it 'can execute the lambda with an argument' do subject.rescue_from ArgumentError, lambda { |e| rack_response(e.message, 400) } subject.get('/rescue_lambda') { fail ArgumentError, 'lambda takes an argument' } get '/rescue_lambda' expect(last_response.status).to eq(400) expect(last_response.body).to eq('lambda takes an argument') end end describe '.rescue_from klass, with: :method_name' do it 'rescues an error with the specified method name' do subject.helpers do def rescue_arg_error error!('500 ArgumentError', 500) end end subject.rescue_from ArgumentError, with: :rescue_arg_error subject.get('/rescue_method') { fail ArgumentError } get '/rescue_method' expect(last_response.status).to eq(500) expect(last_response.body).to eq('500 ArgumentError') end it 'aborts if the specified method name does not exist' do subject.rescue_from :all, with: :not_exist_method subject.get('/rescue_method') { fail StandardError } expect { get '/rescue_method' }.to raise_error(NoMethodError, 'undefined method `not_exist_method\'') end end describe '.rescue_from klass, rescue_subclasses: boolean' do before do module ApiSpec module APIErrors class ParentError < StandardError; end class ChildError < ParentError; end end end end it 'rescues error as well as subclass errors with rescue_subclasses option set' do subject.rescue_from ApiSpec::APIErrors::ParentError, rescue_subclasses: true do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/caught_child' do fail ApiSpec::APIErrors::ChildError end subject.get '/caught_parent' do fail ApiSpec::APIErrors::ParentError end subject.get '/uncaught_parent' do fail StandardError end get '/caught_child' expect(last_response.status).to eql 500 get '/caught_parent' expect(last_response.status).to eql 500 expect { get '/uncaught_parent' }.to raise_error(StandardError) end it 'sets rescue_subclasses to true by default' do subject.rescue_from ApiSpec::APIErrors::ParentError do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/caught_child' do fail ApiSpec::APIErrors::ChildError end get '/caught_child' expect(last_response.status).to eql 500 end it 'does not rescue child errors if rescue_subclasses is false' do subject.rescue_from ApiSpec::APIErrors::ParentError, rescue_subclasses: false do |e| rack_response("rescued from #{e.class.name}", 500) end subject.get '/uncaught' do fail ApiSpec::APIErrors::ChildError end expect { get '/uncaught' }.to raise_error(ApiSpec::APIErrors::ChildError) end end describe '.error_format' do it 'rescues all errors and return :txt' do subject.rescue_from :all subject.format :txt subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.body).to eql 'rain!' end it 'rescues all errors and return :txt with backtrace' do subject.rescue_from :all, backtrace: true subject.format :txt subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.body.start_with?("rain!\r\n")).to be true end it 'rescues all errors with a default formatter' do subject.default_format :foo subject.content_type :foo, 'text/foo' subject.rescue_from :all subject.get '/exception' do fail 'rain!' end get '/exception.foo' expect(last_response.body).to start_with 'rain!' end it 'defaults the error formatter to format' do subject.format :json subject.rescue_from :all subject.content_type :json, 'application/json' subject.content_type :foo, 'text/foo' subject.get '/exception' do fail 'rain!' end get '/exception.json' expect(last_response.body).to eq('{"error":"rain!"}') get '/exception.foo' expect(last_response.body).to eq('{"error":"rain!"}') end context 'class' do before :each do module ApiSpec class CustomErrorFormatter def self.call(message, _backtrace, _options, _env) "message: #{message} @backtrace" end end end end it 'returns a custom error format' do subject.rescue_from :all, backtrace: true subject.error_formatter :txt, ApiSpec::CustomErrorFormatter subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.body).to eq('message: rain! @backtrace') end end describe 'with' do context 'class' do before :each do module ApiSpec class CustomErrorFormatter def self.call(message, _backtrace, _option, _env) "message: #{message} @backtrace" end end end end it 'returns a custom error format' do subject.rescue_from :all, backtrace: true subject.error_formatter :txt, with: ApiSpec::CustomErrorFormatter subject.get('/exception') { fail 'rain!' } get '/exception' expect(last_response.body).to eq('message: rain! @backtrace') end end end it 'rescues all errors and return :json' do subject.rescue_from :all subject.format :json subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.body).to eql '{"error":"rain!"}' end it 'rescues all errors and return :json with backtrace' do subject.rescue_from :all, backtrace: true subject.format :json subject.get '/exception' do fail 'rain!' end get '/exception' json = MultiJson.load(last_response.body) expect(json['error']).to eql 'rain!' expect(json['backtrace'].length).to be > 0 end it 'rescues error! and return txt' do subject.format :txt subject.get '/error' do error!('Access Denied', 401) end get '/error' expect(last_response.body).to eql 'Access Denied' end context 'with json format' do before { subject.format :json } it 'rescues error! called with a string and returns json' do subject.get('/error') { error!(:failure, 401) } end it 'rescues error! called with a symbol and returns json' do subject.get('/error') { error!(:failure, 401) } end it 'rescues error! called with a hash and returns json' do subject.get('/error') { error!({ error: :failure }, 401) } end after do get '/error' expect(last_response.body).to eql('{"error":"failure"}') end end end describe '.content_type' do it 'sets additional content-type' do subject.content_type :xls, 'application/vnd.ms-excel' subject.get :excel do 'some binary content' end get '/excel.xls' expect(last_response.content_type).to eq('application/vnd.ms-excel') end it 'allows to override content-type' do subject.get :content do content_type 'text/javascript' 'var x = 1;' end get '/content' expect(last_response.content_type).to eq('text/javascript') end it 'removes existing content types' do subject.content_type :xls, 'application/vnd.ms-excel' subject.get :excel do 'some binary content' end get '/excel.json' expect(last_response.status).to eq(406) expect(last_response.body).to eq("The requested format 'txt' is not supported.") end end describe '.formatter' do context 'multiple formatters' do before :each do subject.formatter :json, ->(object, _env) { "{\"custom_formatter\":\"#{object[:some]}\"}" } subject.formatter :txt, ->(object, _env) { "custom_formatter: #{object[:some]}" } subject.get :simple do { some: 'hash' } end end it 'sets one formatter' do get '/simple.json' expect(last_response.body).to eql '{"custom_formatter":"hash"}' end it 'sets another formatter' do get '/simple.txt' expect(last_response.body).to eql 'custom_formatter: hash' end end context 'custom formatter' do before :each do subject.content_type :json, 'application/json' subject.content_type :custom, 'application/custom' subject.formatter :custom, ->(object, _env) { "{\"custom_formatter\":\"#{object[:some]}\"}" } subject.get :simple do { some: 'hash' } end end it 'uses json' do get '/simple.json' expect(last_response.body).to eql '{"some":"hash"}' end it 'uses custom formatter' do get '/simple.custom', 'HTTP_ACCEPT' => 'application/custom' expect(last_response.body).to eql '{"custom_formatter":"hash"}' end end context 'custom formatter class' do module ApiSpec module CustomFormatter def self.call(object, _env) "{\"custom_formatter\":\"#{object[:some]}\"}" end end end before :each do subject.content_type :json, 'application/json' subject.content_type :custom, 'application/custom' subject.formatter :custom, ApiSpec::CustomFormatter subject.get :simple do { some: 'hash' } end end it 'uses json' do get '/simple.json' expect(last_response.body).to eql '{"some":"hash"}' end it 'uses custom formatter' do get '/simple.custom', 'HTTP_ACCEPT' => 'application/custom' expect(last_response.body).to eql '{"custom_formatter":"hash"}' end end end describe '.parser' do it 'parses data in format requested by content-type' do subject.format :json subject.post '/data' do { x: params[:x] } end post '/data', '{"x":42}', 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(201) expect(last_response.body).to eq('{"x":42}') end context 'lambda parser' do before :each do subject.content_type :txt, 'text/plain' subject.content_type :custom, 'text/custom' subject.parser :custom, ->(object, _env) { { object.to_sym => object.to_s.reverse } } subject.put :simple do params[:simple] end end ['text/custom', 'text/custom; charset=UTF-8'].each do |content_type| it "uses parser for #{content_type}" do put '/simple', 'simple', 'CONTENT_TYPE' => content_type expect(last_response.status).to eq(200) expect(last_response.body).to eql 'elpmis' end end end context 'custom parser class' do module ApiSpec module CustomParser def self.call(object, _env) { object.to_sym => object.to_s.reverse } end end end before :each do subject.content_type :txt, 'text/plain' subject.content_type :custom, 'text/custom' subject.parser :custom, ApiSpec::CustomParser subject.put :simple do params[:simple] end end it 'uses custom parser' do put '/simple', 'simple', 'CONTENT_TYPE' => 'text/custom' expect(last_response.status).to eq(200) expect(last_response.body).to eql 'elpmis' end end context 'multi_xml' do it "doesn't parse yaml" do subject.put :yaml do params[:tag] end put '/yaml', 'a123', 'CONTENT_TYPE' => 'application/xml' expect(last_response.status).to eq(400) expect(last_response.body).to eql 'Disallowed type attribute: "symbol"' end end context 'none parser class' do before :each do subject.parser :json, nil subject.put 'data' do "body: #{env['api.request.body']}" end end it 'does not parse data' do put '/data', 'not valid json', 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(200) expect(last_response.body).to eq('body: not valid json') end end end describe '.default_format' do before :each do subject.format :json subject.default_format :json end it 'returns data in default format' do subject.get '/data' do { x: 42 } end get '/data' expect(last_response.status).to eq(200) expect(last_response.body).to eq('{"x":42}') end it 'parses data in default format' do subject.post '/data' do { x: params[:x] } end post '/data', '{"x":42}', 'CONTENT_TYPE' => '' expect(last_response.status).to eq(201) expect(last_response.body).to eq('{"x":42}') end end describe '.default_error_status' do it 'allows setting default_error_status' do subject.rescue_from :all subject.default_error_status 200 subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.status).to eql 200 end it 'has a default error status' do subject.rescue_from :all subject.get '/exception' do fail 'rain!' end get '/exception' expect(last_response.status).to eql 500 end it 'uses the default error status in error!' do subject.rescue_from :all subject.default_error_status 400 subject.get '/exception' do error! 'rain!' end get '/exception' expect(last_response.status).to eql 400 end end context 'http_codes' do let(:error_presenter) do Class.new(Grape::Entity) do expose :code expose :static def static 'some static text' end end end it 'is used as presenter' do subject.desc 'some desc', http_codes: [ [408, 'Unauthorized', error_presenter] ] subject.get '/exception' do error!({ code: 408 }, 408) end get '/exception' expect(last_response.status).to eql 408 expect(last_response.body).to eql({ code: 408, static: 'some static text' }.to_json) end it 'presented with' do error = { code: 408, with: error_presenter }.freeze subject.get '/exception' do error! error, 408 end get '/exception' expect(last_response.status).to eql 408 expect(last_response.body).to eql({ code: 408, static: 'some static text' }.to_json) end end context 'routes' do describe 'empty api structure' do it 'returns an empty array of routes' do expect(subject.routes).to eq([]) end end describe 'single method api structure' do before(:each) do subject.get :ping do 'pong' end end it 'returns one route' do expect(subject.routes.size).to eq(1) route = subject.routes[0] expect(route.version).to be_nil expect(route.path).to eq('/ping(.:format)') expect(route.request_method).to eq('GET') end end describe 'api structure with two versions and a namespace' do before :each do subject.version 'v1', using: :path subject.get 'version' do api.version end # version v2 subject.version 'v2', using: :path subject.prefix 'p' subject.namespace 'n1' do namespace 'n2' do get 'version' do api.version end end end end it 'returns the latest version set' do expect(subject.version).to eq('v2') end it 'returns versions' do expect(subject.versions).to eq(%w(v1 v2)) end it 'sets route paths' do expect(subject.routes.size).to be >= 2 expect(subject.routes[0].path).to eq('/:version/version(.:format)') expect(subject.routes[1].path).to eq('/p/:version/n1/n2/version(.:format)') end it 'sets route versions' do expect(subject.routes[0].version).to eq('v1') expect(subject.routes[1].version).to eq('v2') end it 'sets a nested namespace' do expect(subject.routes[1].namespace).to eq('/n1/n2') end it 'sets prefix' do expect(subject.routes[1].prefix).to eq('p') end end describe 'api structure with additional parameters' do before(:each) do subject.params do requires :token, desc: 'a token' optional :limit, desc: 'the limit' end subject.get 'split/:string' do params[:string].split(params[:token], (params[:limit] || 0).to_i) end end it 'splits a string' do get '/split/a,b,c.json', token: ',' expect(last_response.body).to eq('["a","b","c"]') end it 'splits a string with limit' do get '/split/a,b,c.json', token: ',', limit: '2' expect(last_response.body).to eq('["a","b,c"]') end it 'sets params' do expect(subject.routes.map { |route| { params: route.params } }).to eq [ { params: { 'string' => '', 'token' => { required: true, desc: 'a token' }, 'limit' => { required: false, desc: 'the limit' } } } ] end end describe 'api structure with multiple apis' do before(:each) do subject.params do requires :one, desc: 'a token' optional :two, desc: 'the limit' end subject.get 'one' do end subject.params do requires :three, desc: 'a token' optional :four, desc: 'the limit' end subject.get 'two' do end end it 'sets params' do expect(subject.routes.map { |route| { params: route.params } }).to eq [ { params: { 'one' => { required: true, desc: 'a token' }, 'two' => { required: false, desc: 'the limit' } } }, { params: { 'three' => { required: true, desc: 'a token' }, 'four' => { required: false, desc: 'the limit' } } } ] end end describe 'api structure with an api without params' do before(:each) do subject.params do requires :one, desc: 'a token' optional :two, desc: 'the limit' end subject.get 'one' do end subject.get 'two' do end end it 'sets params' do expect(subject.routes.map { |route| { params: route.params } }).to eq [ { params: { 'one' => { required: true, desc: 'a token' }, 'two' => { required: false, desc: 'the limit' } } }, { params: {} } ] end end describe 'api with a custom route setting' do before(:each) do subject.route_setting :custom, key: 'value' subject.get 'one' end it 'exposed' do expect(subject.routes.count).to eq 1 route = subject.routes.first expect(route.settings[:custom]).to eq(key: 'value') end end describe 'status' do it 'can be set to arbitrary Fixnum value' do subject.get '/foo' do status 210 end get '/foo' expect(last_response.status).to eq 210 end it 'can be set with a status code symbol' do subject.get '/foo' do status :see_other end get '/foo' expect(last_response.status).to eq 303 end end end context 'desc' do it 'empty array of routes' do expect(subject.routes).to eq([]) end it 'empty array of routes' do subject.desc 'grape api' expect(subject.routes).to eq([]) end it 'describes a method' do subject.desc 'first method' subject.get :first do; end expect(subject.routes.length).to eq(1) route = subject.routes.first expect(route.description).to eq('first method') expect(route.route_foo).to be_nil expect(route.params).to eq({}) expect(route.options).to be_a_kind_of(Hash) end it 'has params which does not include format and version as named captures' do subject.version :v1, using: :path subject.get :first do; end param_keys = subject.routes.first.params.keys expect(param_keys).not_to include('format') expect(param_keys).not_to include('version') end it 'describes methods separately' do subject.desc 'first method' subject.get :first do; end subject.desc 'second method' subject.get :second do; end expect(subject.routes.count).to eq(2) expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: 'first method', params: {} }, { description: 'second method', params: {} } ] end it 'resets desc' do subject.desc 'first method' subject.get :first do; end subject.get :second do; end expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: 'first method', params: {} }, { description: nil, params: {} } ] end it 'namespaces and describe arbitrary parameters' do subject.namespace 'ns' do desc 'ns second', foo: 'bar' get 'second' do; end end expect(subject.routes.map { |route| { description: route.description, foo: route.route_foo, params: route.params } }).to eq [ { description: 'ns second', foo: 'bar', params: {} } ] end it 'includes details' do subject.desc 'method', details: 'method details' subject.get 'method' do; end expect(subject.routes.map { |route| { description: route.description, details: route.details, params: route.params } }).to eq [ { description: 'method', details: 'method details', params: {} } ] end it 'describes a method with parameters' do subject.desc 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } subject.get 'reverse' do params[:s].reverse end expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } } ] end it 'does not inherit param descriptions in consequent namespaces' do subject.desc 'global description' subject.params do requires :param1 optional :param2 end subject.namespace 'ns1' do get do; end end subject.params do optional :param2 end subject.namespace 'ns2' do get do; end end routes_doc = subject.routes.map { |route| { description: route.description, params: route.params } } expect(routes_doc).to eq [ { description: 'global description', params: { 'param1' => { required: true }, 'param2' => { required: false } } }, { description: 'global description', params: { 'param2' => { required: false } } } ] end it 'merges the parameters of the namespace with the parameters of the method' do subject.desc 'namespace' subject.params do requires :ns_param, desc: 'namespace parameter' end subject.namespace 'ns' do desc 'method' params do optional :method_param, desc: 'method parameter' end get 'method' do; end end routes_doc = subject.routes.map { |route| { description: route.description, params: route.params } } expect(routes_doc).to eq [ { description: 'method', params: { 'ns_param' => { required: true, desc: 'namespace parameter' }, 'method_param' => { required: false, desc: 'method parameter' } } } ] end it 'merges the parameters of nested namespaces' do subject.desc 'ns1' subject.params do optional :ns_param, desc: 'ns param 1' requires :ns1_param, desc: 'ns1 param' end subject.namespace 'ns1' do desc 'ns2' params do requires :ns_param, desc: 'ns param 2' requires :ns2_param, desc: 'ns2 param' end namespace 'ns2' do desc 'method' params do optional :method_param, desc: 'method param' end get 'method' do; end end end expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: 'method', params: { 'ns_param' => { required: true, desc: 'ns param 2' }, 'ns1_param' => { required: true, desc: 'ns1 param' }, 'ns2_param' => { required: true, desc: 'ns2 param' }, 'method_param' => { required: false, desc: 'method param' } } } ] end it 'groups nested params and prevents overwriting of params with same name in different groups' do subject.desc 'method' subject.params do group :group1, type: Array do optional :param1, desc: 'group1 param1 desc' requires :param2, desc: 'group1 param2 desc' end group :group2, type: Array do optional :param1, desc: 'group2 param1 desc' requires :param2, desc: 'group2 param2 desc' end end subject.get 'method' do; end expect(subject.routes.map(&:params)).to eq [{ 'group1' => { required: true, type: 'Array' }, 'group1[param1]' => { required: false, desc: 'group1 param1 desc' }, 'group1[param2]' => { required: true, desc: 'group1 param2 desc' }, 'group2' => { required: true, type: 'Array' }, 'group2[param1]' => { required: false, desc: 'group2 param1 desc' }, 'group2[param2]' => { required: true, desc: 'group2 param2 desc' } }] end it 'uses full name of parameters in nested groups' do subject.desc 'nesting' subject.params do requires :root_param, desc: 'root param' group :nested, type: Array do requires :nested_param, desc: 'nested param' end end subject.get 'method' do; end expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: 'nesting', params: { 'root_param' => { required: true, desc: 'root param' }, 'nested' => { required: true, type: 'Array' }, 'nested[nested_param]' => { required: true, desc: 'nested param' } } } ] end it 'allows to set the type attribute on :group element' do subject.params do group :foo, type: Array do optional :bar end end end it 'parses parameters when no description is given' do subject.params do requires :one_param, desc: 'one param' end subject.get 'method' do; end expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: nil, params: { 'one_param' => { required: true, desc: 'one param' } } } ] end it 'does not symbolize params' do subject.desc 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } subject.get 'reverse/:s' do params[:s].reverse end expect(subject.routes.map { |route| { description: route.description, params: route.params } }).to eq [ { description: 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } } ] end end describe '.mount' do let(:mounted_app) { ->(_env) { [200, {}, ['MOUNTED']] } } context 'with a bare rack app' do before do subject.mount mounted_app => '/mounty' end it 'makes a bare Rack app available at the endpoint' do get '/mounty' expect(last_response.body).to eq('MOUNTED') end it 'anchors the routes, passing all subroutes to it' do get '/mounty/awesome' expect(last_response.body).to eq('MOUNTED') end it 'is able to cascade' do subject.mount lambda { |env| headers = {} headers['X-Cascade'] == 'pass' unless env['PATH_INFO'].include?('boo') [200, headers, ['Farfegnugen']] } => '/' get '/boo' expect(last_response.body).to eq('Farfegnugen') get '/mounty' expect(last_response.body).to eq('MOUNTED') end end context 'without a hash' do it 'calls through setting the route to "/"' do subject.mount mounted_app get '/' expect(last_response.body).to eq('MOUNTED') end end context 'mounting an API' do it 'applies the settings of the mounting api' do subject.version 'v1', using: :path subject.namespace :cool do app = Class.new(Grape::API) app.get('/awesome') do 'yo' end mount app end get '/v1/cool/awesome' expect(last_response.body).to eq('yo') end it 'applies the settings to nested mounted apis' do subject.version 'v1', using: :path subject.namespace :cool do inner_app = Class.new(Grape::API) inner_app.get('/awesome') do 'yo' end app = Class.new(Grape::API) app.mount inner_app mount app end get '/v1/cool/awesome' expect(last_response.body).to eq('yo') end it 'inherits rescues even when some defined by mounted' do subject.rescue_from :all do |e| rack_response("rescued from #{e.message}", 202) end app = Class.new(Grape::API) subject.namespace :mounted do app.rescue_from ArgumentError app.get('/fail') { fail 'doh!' } mount app end get '/mounted/fail' expect(last_response.status).to eql 202 expect(last_response.body).to eq('rescued from doh!') end it 'collects the routes of the mounted api' do subject.namespace :cool do app = Class.new(Grape::API) app.get('/awesome') {} app.post('/sauce') {} mount app end expect(subject.routes.size).to eq(2) expect(subject.routes.first.path).to match(%r{\/cool\/awesome}) expect(subject.routes.last.path).to match(%r{\/cool\/sauce}) end it 'mounts on a path' do subject.namespace :cool do app = Class.new(Grape::API) app.get '/awesome' do 'sauce' end mount app => '/mounted' end get '/mounted/cool/awesome' expect(last_response.status).to eq(200) expect(last_response.body).to eq('sauce') end it 'mounts on a nested path' do APP1 = Class.new(Grape::API) APP2 = Class.new(Grape::API) APP2.get '/nice' do 'play' end # note that the reverse won't work, mount from outside-in APP3 = subject APP3.mount APP1 => '/app1' APP1.mount APP2 => '/app2' get '/app1/app2/nice' expect(last_response.status).to eq(200) expect(last_response.body).to eq('play') options '/app1/app2/nice' expect(last_response.status).to eq(204) end it 'responds to options' do app = Class.new(Grape::API) app.get '/colour' do 'red' end app.namespace :pears do get '/colour' do 'green' end end subject.namespace :apples do mount app end get '/apples/colour' expect(last_response.status).to eql 200 expect(last_response.body).to eq('red') options '/apples/colour' expect(last_response.status).to eql 204 get '/apples/pears/colour' expect(last_response.status).to eql 200 expect(last_response.body).to eq('green') options '/apples/pears/colour' expect(last_response.status).to eql 204 end it 'responds to options with path versioning' do subject.version 'v1', using: :path subject.namespace :apples do app = Class.new(Grape::API) app.get('/colour') do 'red' end mount app end get '/v1/apples/colour' expect(last_response.status).to eql 200 expect(last_response.body).to eq('red') options '/v1/apples/colour' expect(last_response.status).to eql 204 end it 'mounts a versioned API with nested resources' do api = Class.new(Grape::API) do version 'v1' resources :users do get :hello do 'hello users' end end end subject.mount api get '/v1/users/hello' expect(last_response.body).to eq('hello users') end it 'mounts a prefixed API with nested resources' do api = Class.new(Grape::API) do prefix 'api' resources :users do get :hello do 'hello users' end end end subject.mount api get '/api/users/hello' expect(last_response.body).to eq('hello users') end it 'applies format to a mounted API with nested resources' do api = Class.new(Grape::API) do format :json resources :users do get do { users: true } end end end subject.mount api get '/users' expect(last_response.body).to eq({ users: true }.to_json) end it 'applies auth to a mounted API with nested resources' do api = Class.new(Grape::API) do format :json http_basic do |username, password| username == 'username' && password == 'password' end resources :users do get do { users: true } end end end subject.mount api get '/users' expect(last_response.status).to eq(401) get '/users', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('username', 'password') expect(last_response.body).to eq({ users: true }.to_json) end it 'mounts multiple versioned APIs with nested resources' do api1 = Class.new(Grape::API) do version 'one', using: :header, vendor: 'test' resources :users do get :hello do 'one' end end end api2 = Class.new(Grape::API) do version 'two', using: :header, vendor: 'test' resources :users do get :hello do 'two' end end end subject.mount api1 subject.mount api2 versioned_get '/users/hello', 'one', using: :header, vendor: 'test' expect(last_response.body).to eq('one') versioned_get '/users/hello', 'two', using: :header, vendor: 'test' expect(last_response.body).to eq('two') end end end describe '.endpoints' do it 'adds one for each route created' do subject.get '/' subject.post '/' expect(subject.endpoints.size).to eq(2) end end describe '.compile' do it 'sets the instance' do expect(subject.instance).to be_nil subject.compile expect(subject.instance).to be_kind_of(subject) end end describe '.change!' do it 'invalidates any compiled instance' do subject.compile subject.change! expect(subject.instance).to be_nil end end describe '.endpoint' do before(:each) do subject.format :json subject.get '/endpoint/options' do { path: options[:path], source_location: source.source_location } end end it 'path' do get '/endpoint/options' options = MultiJson.load(last_response.body) expect(options['path']).to eq(['/endpoint/options']) expect(options['source_location'][0]).to include 'api_spec.rb' expect(options['source_location'][1].to_i).to be > 0 end end describe '.route' do context 'plain' do before(:each) do subject.get '/' do route.path end subject.get '/path' do route.path end end it 'provides access to route info' do get '/' expect(last_response.body).to eq('/(.:format)') get '/path' expect(last_response.body).to eq('/path(.:format)') end end context 'with desc' do before(:each) do subject.desc 'returns description' subject.get '/description' do route.description end subject.desc 'returns parameters', params: { 'x' => 'y' } subject.get '/params/:id' do route.params[params[:id]] end end it 'returns route description' do get '/description' expect(last_response.body).to eq('returns description') end it 'returns route parameters' do get '/params/x' expect(last_response.body).to eq('y') end end end describe '.format' do context ':txt' do before(:each) do subject.format :txt subject.content_type :json, 'application/json' subject.get '/meaning_of_life' do { meaning_of_life: 42 } end end it 'forces txt without an extension' do get '/meaning_of_life' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end it 'does not force txt with an extension' do get '/meaning_of_life.json' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_json) end it 'forces txt from a non-accepting header' do get '/meaning_of_life', {}, 'HTTP_ACCEPT' => 'application/json' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end end context ':txt only' do before(:each) do subject.format :txt subject.get '/meaning_of_life' do { meaning_of_life: 42 } end end it 'forces txt without an extension' do get '/meaning_of_life' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end it 'accepts specified extension' do get '/meaning_of_life.txt' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end it 'does not accept extensions other than specified' do get '/meaning_of_life.json' expect(last_response.status).to eq(404) end it 'forces txt from a non-accepting header' do get '/meaning_of_life', {}, 'HTTP_ACCEPT' => 'application/json' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end end context ':json' do before(:each) do subject.format :json subject.content_type :txt, 'text/plain' subject.get '/meaning_of_life' do { meaning_of_life: 42 } end end it 'forces json without an extension' do get '/meaning_of_life' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_json) end it 'does not force json with an extension' do get '/meaning_of_life.txt' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end it 'forces json from a non-accepting header' do get '/meaning_of_life', {}, 'HTTP_ACCEPT' => 'text/html' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_json) end it 'can be overwritten with an explicit content type' do subject.get '/meaning_of_life_with_content_type' do content_type 'text/plain' { meaning_of_life: 42 }.to_s end get '/meaning_of_life_with_content_type' expect(last_response.body).to eq({ meaning_of_life: 42 }.to_s) end it 'raised :error from middleware' do middleware = Class.new(Grape::Middleware::Base) do def before throw :error, message: 'Unauthorized', status: 42 end end subject.use middleware subject.get do end get '/' expect(last_response.status).to eq(42) expect(last_response.body).to eq({ error: 'Unauthorized' }.to_json) end end context ':serializable_hash' do before(:each) do class SerializableHashExample def serializable_hash { abc: 'def' } end end subject.format :serializable_hash end it 'instance' do subject.get '/example' do SerializableHashExample.new end get '/example' expect(last_response.body).to eq('{"abc":"def"}') end it 'root' do subject.get '/example' do { 'root' => SerializableHashExample.new } end get '/example' expect(last_response.body).to eq('{"root":{"abc":"def"}}') end it 'array' do subject.get '/examples' do [SerializableHashExample.new, SerializableHashExample.new] end get '/examples' expect(last_response.body).to eq('[{"abc":"def"},{"abc":"def"}]') end end context ':xml' do before(:each) do subject.format :xml end it 'string' do subject.get '/example' do 'example' end get '/example' expect(last_response.status).to eq(500) expect(last_response.body).to eq <<-XML cannot convert String to xml XML end it 'hash' do subject.get '/example' do { example1: 'example1', example2: 'example2' } end get '/example' expect(last_response.status).to eq(200) expect(last_response.body).to eq <<-XML example1 example2 XML end it 'array' do subject.get '/example' do %w(example1 example2) end get '/example' expect(last_response.status).to eq(200) expect(last_response.body).to eq <<-XML example1 example2 XML end it 'raised :error from middleware' do middleware = Class.new(Grape::Middleware::Base) do def before throw :error, message: 'Unauthorized', status: 42 end end subject.use middleware subject.get do end get '/' expect(last_response.status).to eq(42) expect(last_response.body).to eq <<-XML Unauthorized XML end end end context 'catch-all' do before do api1 = Class.new(Grape::API) api1.version 'v1', using: :path api1.get 'hello' do 'v1' end api2 = Class.new(Grape::API) api2.version 'v2', using: :path api2.get 'hello' do 'v2' end subject.mount api1 subject.mount api2 end [true, false].each do |anchor| it "anchor=#{anchor}" do subject.route :any, '*path', anchor: anchor do error!("Unrecognized request path: #{params[:path]} - #{env['PATH_INFO']}#{env['SCRIPT_NAME']}", 404) end get '/v1/hello' expect(last_response.status).to eq(200) expect(last_response.body).to eq('v1') get '/v2/hello' expect(last_response.status).to eq(200) expect(last_response.body).to eq('v2') options '/v2/hello' expect(last_response.status).to eq(204) expect(last_response.body).to be_blank head '/v2/hello' expect(last_response.status).to eq(200) expect(last_response.body).to be_blank get '/foobar' expect(last_response.status).to eq(404) expect(last_response.body).to eq('Unrecognized request path: foobar - /foobar') end end end context 'cascading' do context 'via version' do it 'cascades' do subject.version 'v1', using: :path, cascade: true get '/v1/hello' expect(last_response.status).to eq(404) expect(last_response.headers['X-Cascade']).to eq('pass') end it 'does not cascade' do subject.version 'v2', using: :path, cascade: false get '/v2/hello' expect(last_response.status).to eq(404) expect(last_response.headers.keys).not_to include 'X-Cascade' end end context 'via endpoint' do it 'cascades' do subject.cascade true get '/hello' expect(last_response.status).to eq(404) expect(last_response.headers['X-Cascade']).to eq('pass') end it 'does not cascade' do subject.cascade false get '/hello' expect(last_response.status).to eq(404) expect(last_response.headers.keys).not_to include 'X-Cascade' end end end context 'with json default_error_formatter' do it 'returns json error' do subject.content_type :json, 'application/json' subject.default_error_formatter :json subject.get '/something' do 'foo' end get '/something' expect(last_response.status).to eq(406) expect(last_response.body).to eq("{\"error\":\"The requested format 'txt' is not supported.\"}") end end context 'body' do context 'false' do before do subject.get '/blank' do body false end end it 'returns blank body' do get '/blank' expect(last_response.status).to eq(204) expect(last_response.body).to be_blank end end context 'plain text' do before do subject.get '/text' do content_type 'text/plain' body 'Hello World' 'ignored' end end it 'returns blank body' do get '/text' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'Hello World' end end end end grape-0.16.2/spec/grape/endpoint_spec.rb0000644000004100000410000010474212706307016020147 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Endpoint do subject { Class.new(Grape::API) } def app subject end describe '.before_each' do after { Grape::Endpoint.before_each(nil) } it 'is settable via block' do block = ->(_endpoint) { 'noop' } Grape::Endpoint.before_each(&block) expect(Grape::Endpoint.before_each.first).to eq(block) end it 'is settable via reference' do block = ->(_endpoint) { 'noop' } Grape::Endpoint.before_each block expect(Grape::Endpoint.before_each.first).to eq(block) end it 'is able to override a helper' do subject.get('/') { current_user } expect { get '/' }.to raise_error(NameError) Grape::Endpoint.before_each do |endpoint| allow(endpoint).to receive(:current_user).and_return('Bob') end get '/' expect(last_response.body).to eq('Bob') Grape::Endpoint.before_each(nil) expect { get '/' }.to raise_error(NameError) end it 'is able to stack helper' do subject.get('/') do authenticate_user! current_user end expect { get '/' }.to raise_error(NameError) Grape::Endpoint.before_each do |endpoint| allow(endpoint).to receive(:current_user).and_return('Bob') end Grape::Endpoint.before_each do |endpoint| allow(endpoint).to receive(:authenticate_user!).and_return(true) end get '/' expect(last_response.body).to eq('Bob') Grape::Endpoint.before_each(nil) expect { get '/' }.to raise_error(NameError) end end describe '#initialize' do it 'takes a settings stack, options, and a block' do p = proc {} expect do Grape::Endpoint.new(Grape::Util::InheritableSetting.new, { path: '/', method: :get }, &p) end.not_to raise_error end end it 'sets itself in the env upon call' do subject.get('/') { 'Hello world.' } get '/' expect(last_request.env['api.endpoint']).to be_kind_of(Grape::Endpoint) end describe '#status' do it 'is callable from within a block' do subject.get('/home') do status 206 'Hello' end get '/home' expect(last_response.status).to eq(206) expect(last_response.body).to eq('Hello') end it 'is set as default to 200 for get' do memoized_status = nil subject.get('/home') do memoized_status = status 'Hello' end get '/home' expect(last_response.status).to eq(200) expect(memoized_status).to eq(200) expect(last_response.body).to eq('Hello') end it 'is set as default to 201 for post' do memoized_status = nil subject.post('/home') do memoized_status = status 'Hello' end post '/home' expect(last_response.status).to eq(201) expect(memoized_status).to eq(201) expect(last_response.body).to eq('Hello') end end describe '#header' do it 'is callable from within a block' do subject.get('/hey') do header 'X-Awesome', 'true' 'Awesome' end get '/hey' expect(last_response.headers['X-Awesome']).to eq('true') end end describe '#headers' do before do subject.get('/headers') do headers.to_json end end it 'includes request headers' do get '/headers' expect(JSON.parse(last_response.body)).to eq( 'Host' => 'example.org', 'Cookie' => '' ) end it 'includes additional request headers' do get '/headers', nil, 'HTTP_X_GRAPE_CLIENT' => '1' expect(JSON.parse(last_response.body)['X-Grape-Client']).to eq('1') end it 'includes headers passed as symbols' do env = Rack::MockRequest.env_for('/headers') env['HTTP_SYMBOL_HEADER'.to_sym] = 'Goliath passes symbols' body = subject.call(env)[2].body.first expect(JSON.parse(body)['Symbol-Header']).to eq('Goliath passes symbols') end end describe '#cookies' do it 'is callable from within a block' do subject.get('/get/cookies') do cookies['my-awesome-cookie1'] = 'is cool' cookies['my-awesome-cookie2'] = { value: 'is cool too', domain: 'my.example.com', path: '/', secure: true } cookies[:cookie3] = 'symbol' cookies['cookie4'] = 'secret code here' end get('/get/cookies') expect(last_response.headers['Set-Cookie'].split("\n").sort).to eql [ 'cookie3=symbol', 'cookie4=secret+code+here', 'my-awesome-cookie1=is+cool', 'my-awesome-cookie2=is+cool+too; domain=my.example.com; path=/; secure' ] end it 'sets browser cookies and does not set response cookies' do subject.get('/username') do cookies[:username] end get('/username', {}, 'HTTP_COOKIE' => 'username=mrplum; sandbox=true') expect(last_response.body).to eq('mrplum') expect(last_response.headers['Set-Cookie']).to be_nil end it 'sets and update browser cookies' do subject.get('/username') do cookies[:sandbox] = true if cookies[:sandbox] == 'false' cookies[:username] += '_test' end get('/username', {}, 'HTTP_COOKIE' => 'username=user; sandbox=false') expect(last_response.body).to eq('user_test') expect(last_response.headers['Set-Cookie']).to match(/username=user_test/) expect(last_response.headers['Set-Cookie']).to match(/sandbox=true/) end it 'deletes cookie' do subject.get('/test') do sum = 0 cookies.each do |name, val| sum += val.to_i cookies.delete name end sum end get '/test', {}, 'HTTP_COOKIE' => 'delete_this_cookie=1; and_this=2' expect(last_response.body).to eq('3') cookies = Hash[last_response.headers['Set-Cookie'].split("\n").map do |set_cookie| cookie = CookieJar::Cookie.from_set_cookie 'http://localhost/test', set_cookie [cookie.name, cookie] end] expect(cookies.size).to eq(2) %w(and_this delete_this_cookie).each do |cookie_name| cookie = cookies[cookie_name] expect(cookie).not_to be_nil expect(cookie.value).to eq('deleted') expect(cookie.expired?).to be true end end it 'deletes cookies with path' do subject.get('/test') do sum = 0 cookies.each do |name, val| sum += val.to_i cookies.delete name, path: '/test' end sum end get('/test', {}, 'HTTP_COOKIE' => 'delete_this_cookie=1; and_this=2') expect(last_response.body).to eq('3') cookies = Hash[last_response.headers['Set-Cookie'].split("\n").map do |set_cookie| cookie = CookieJar::Cookie.from_set_cookie 'http://localhost/test', set_cookie [cookie.name, cookie] end] expect(cookies.size).to eq(2) %w(and_this delete_this_cookie).each do |cookie_name| cookie = cookies[cookie_name] expect(cookie).not_to be_nil expect(cookie.value).to eq('deleted') expect(cookie.path).to eq('/test') expect(cookie.expired?).to be true end end end describe '#declared' do before do subject.params do requires :first optional :second optional :third, default: 'third-default' optional :nested, type: Hash do optional :fourth end end end it 'does not work in a before filter' do subject.before do declared(params) end subject.get('/declared') { declared(params) } expect { get('/declared') }.to raise_error( Grape::DSL::InsideRoute::MethodNotYetAvailable) end it 'has as many keys as there are declared params' do inner_params = nil subject.get '/declared' do inner_params = declared(params).keys '' end get '/declared?first=present' expect(last_response.status).to eq(200) expect(inner_params.size).to eq(4) end it 'has a optional param with default value all the time' do inner_params = nil subject.get '/declared' do inner_params = declared(params) '' end get '/declared?first=one' expect(last_response.status).to eq(200) expect(inner_params[:third]).to eql('third-default') end it 'builds nested params' do inner_params = nil subject.get '/declared' do inner_params = declared(params) '' end get '/declared?first=present&nested[fourth]=1' expect(last_response.status).to eq(200) expect(inner_params[:nested].keys.size).to eq 1 end it 'builds nested params when given array' do subject.get '/dummy' do end subject.params do requires :first optional :second optional :third, default: 'third-default' optional :nested, type: Array do optional :fourth end end inner_params = nil subject.get '/declared' do inner_params = declared(params) '' end get '/declared?first=present&nested[][fourth]=1&nested[][fourth]=2' expect(last_response.status).to eq(200) expect(inner_params[:nested].size).to eq 2 end it 'builds nested params' do inner_params = nil subject.get '/declared' do inner_params = declared(params) '' end get '/declared?first=present&nested[fourth]=1' expect(last_response.status).to eq(200) expect(inner_params[:nested].keys.size).to eq 1 end context 'sets nested array when the param is missing' do it 'to be array when include_missing is true' do inner_params = nil subject.get '/declared' do inner_params = declared(params, include_missing: true) '' end get '/declared?first=present' expect(last_response.status).to eq(200) expect(inner_params[:nested]).to be_a(Array) end it 'to be nil when include_missing is false' do inner_params = nil subject.get '/declared' do inner_params = declared(params, include_missing: false) '' end get '/declared?first=present' expect(last_response.status).to eq(200) expect(inner_params[:nested]).to be_nil end end it 'filters out any additional params that are given' do inner_params = nil subject.get '/declared' do inner_params = declared(params) '' end get '/declared?first=one&other=two' expect(last_response.status).to eq(200) expect(inner_params.key?(:other)).to eq false end it 'stringifies if that option is passed' do inner_params = nil subject.get '/declared' do inner_params = declared(params, stringify: true) '' end get '/declared?first=one&other=two' expect(last_response.status).to eq(200) expect(inner_params['first']).to eq 'one' end it 'does not include missing attributes if that option is passed' do subject.get '/declared' do error! 400, 'expected nil' if declared(params, include_missing: false)[:second] '' end get '/declared?first=one&other=two' expect(last_response.status).to eq(200) end it 'includes attributes with value that evaluates to false' do subject.params do requires :first optional :boolean end subject.post '/declared' do error!('expected false', 400) if declared(params, include_missing: false)[:boolean] != false '' end post '/declared', MultiJson.dump(first: 'one', boolean: false), 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(201) end it 'includes attributes with value that evaluates to nil' do subject.params do requires :first optional :second end subject.post '/declared' do error!('expected nil', 400) unless declared(params, include_missing: false)[:second].nil? '' end post '/declared', MultiJson.dump(first: 'one', second: nil), 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(201) end it 'does not include missing attributes when there are nested hashes' do subject.get '/dummy' do end subject.params do requires :first optional :second optional :third, default: nil optional :nested, type: Hash do optional :fourth, default: nil optional :fifth, default: nil requires :nested_nested, type: Hash do optional :sixth, default: 'sixth-default' optional :seven, default: nil end end end inner_params = nil subject.get '/declared' do inner_params = declared(params, include_missing: false) '' end get '/declared?first=present&nested[fourth]=&nested[nested_nested][sixth]=sixth' expect(last_response.status).to eq(200) expect(inner_params[:first]).to eq 'present' expect(inner_params[:nested].keys).to eq %w(fourth fifth nested_nested) expect(inner_params[:nested][:fourth]).to eq '' expect(inner_params[:nested][:nested_nested].keys).to eq %w(sixth seven) expect(inner_params[:nested][:nested_nested][:sixth]).to eq 'sixth' end end describe '#declared; call from child namespace' do before do subject.format :json subject.namespace :something do params do requires :id, type: Integer end resource ':id' do params do requires :foo optional :bar end get do { params: params, declared_params: declared(params) } end params do requires :happy optional :days end get '/test' do { params: params, declared_params: declared(params, include_parent_namespaces: false) } end end end end it 'should include params defined in the parent namespace' do get '/something/123', foo: 'test', extra: 'hello' expect(last_response.status).to eq 200 json = JSON.parse(last_response.body, symbolize_names: true) expect(json[:params][:id]).to eq 123 expect(json[:declared_params].keys).to match_array [:foo, :bar, :id] end it 'does not include params defined in the parent namespace with include_parent_namespaces: false' do get '/something/123/test', happy: 'test', extra: 'hello' expect(last_response.status).to eq 200 json = JSON.parse(last_response.body, symbolize_names: true) expect(json[:params][:id]).to eq 123 expect(json[:declared_params].keys).to match_array [:happy, :days] end end describe '#params' do it 'is available to the caller' do subject.get('/hey') do params[:howdy] end get '/hey?howdy=hey' expect(last_response.body).to eq('hey') end it 'parses from path segments' do subject.get('/hey/:id') do params[:id] end get '/hey/12' expect(last_response.body).to eq('12') end it 'deeply converts nested params' do subject.get '/location' do params[:location][:city] end get '/location?location[city]=Dallas' expect(last_response.body).to eq('Dallas') end context 'with special requirements' do it 'parses email param with provided requirements for params' do subject.get('/:person_email', requirements: { person_email: /.*/ }) do params[:person_email] end get '/someone@example.com' expect(last_response.body).to eq('someone@example.com') get 'someone@example.com.pl' expect(last_response.body).to eq('someone@example.com.pl') end it 'parses many params with provided regexps' do subject.get('/:person_email/test/:number', requirements: { person_email: /someone@(.*).com/, number: /[0-9]/ }) do params[:person_email] << params[:number] end get '/someone@example.com/test/1' expect(last_response.body).to eq('someone@example.com1') get '/someone@testing.wrong/test/1' expect(last_response.status).to eq(404) get 'someone@test.com/test/wrong_number' expect(last_response.status).to eq(404) get 'someone@test.com/wrong_middle/1' expect(last_response.status).to eq(404) end context 'namespace requirements' do before :each do subject.namespace :outer, requirements: { person_email: /abc@(.*).com/ } do get('/:person_email') do params[:person_email] end namespace :inner, requirements: { number: /[0-9]/, person_email: /someone@(.*).com/ }do get '/:person_email/test/:number' do params[:person_email] << params[:number] end end end end it 'parse email param with provided requirements for params' do get '/outer/abc@example.com' expect(last_response.body).to eq('abc@example.com') end it "should override outer namespace's requirements" do get '/outer/inner/someone@testing.wrong/test/1' expect(last_response.status).to eq(404) get '/outer/inner/someone@testing.com/test/1' expect(last_response.status).to eq(200) expect(last_response.body).to eq('someone@testing.com1') end end end context 'from body parameters' do before(:each) do subject.post '/request_body' do params[:user] end subject.put '/request_body' do params[:user] end end it 'converts JSON bodies to params' do post '/request_body', MultiJson.dump(user: 'Bobby T.'), 'CONTENT_TYPE' => 'application/json' expect(last_response.body).to eq('Bobby T.') end it 'does not convert empty JSON bodies to params' do put '/request_body', '', 'CONTENT_TYPE' => 'application/json' expect(last_response.body).to eq('') end it 'converts XML bodies to params' do post '/request_body', 'Bobby T.', 'CONTENT_TYPE' => 'application/xml' expect(last_response.body).to eq('Bobby T.') end it 'converts XML bodies to params' do put '/request_body', 'Bobby T.', 'CONTENT_TYPE' => 'application/xml' expect(last_response.body).to eq('Bobby T.') end it 'does not include parameters not defined by the body' do subject.post '/omitted_params' do error! 400, 'expected nil' if params[:version] params[:user] end post '/omitted_params', MultiJson.dump(user: 'Bob'), 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(201) expect(last_response.body).to eq('Bob') end end it 'responds with a 406 for an unsupported content-type' do subject.format :json # subject.content_type :json, "application/json" subject.put '/request_body' do params[:user] end put '/request_body', 'Bobby T.', 'CONTENT_TYPE' => 'application/xml' expect(last_response.status).to eq(406) expect(last_response.body).to eq('{"error":"The requested content-type \'application/xml\' is not supported."}') end context 'content type with params' do before do subject.format :json subject.content_type :json, 'application/json; charset=utf-8' subject.post do params[:data] end post '/', MultiJson.dump(data: { some: 'payload' }), 'CONTENT_TYPE' => 'application/json' end it 'should not response with 406 for same type without params' do expect(last_response.status).not_to be 406 end it 'should response with given content type in headers' do expect(last_response.headers['Content-Type']).to eq 'application/json; charset=utf-8' end end context 'precedence' do before do subject.format :json subject.namespace '/:id' do get do { params: params[:id] } end post do { params: params[:id] } end put do { params: params[:id] } end end end it 'route string params have higher precedence than body params' do post '/123', { id: 456 }.to_json expect(JSON.parse(last_response.body)['params']).to eq '123' put '/123', { id: 456 }.to_json expect(JSON.parse(last_response.body)['params']).to eq '123' end it 'route string params have higher precedence than URL params' do get '/123?id=456' expect(JSON.parse(last_response.body)['params']).to eq '123' post '/123?id=456' expect(JSON.parse(last_response.body)['params']).to eq '123' end end end describe '#error!' do it 'accepts a message' do subject.get('/hey') do error! 'This is not valid.' 'This is valid.' end get '/hey' expect(last_response.status).to eq(500) expect(last_response.body).to eq('This is not valid.') end it 'accepts a code' do subject.get('/hey') do error! 'Unauthorized.', 401 end get '/hey' expect(last_response.status).to eq(401) expect(last_response.body).to eq('Unauthorized.') end it 'accepts an object and render it in format' do subject.get '/hey' do error!({ 'dude' => 'rad' }, 403) end get '/hey.json' expect(last_response.status).to eq(403) expect(last_response.body).to eq('{"dude":"rad"}') end it 'accepts a frozen object' do subject.get '/hey' do error!({ 'dude' => 'rad' }.freeze, 403) end get '/hey.json' expect(last_response.status).to eq(403) expect(last_response.body).to eq('{"dude":"rad"}') end it 'can specifiy headers' do subject.get '/hey' do error!({ 'dude' => 'rad' }, 403, 'X-Custom' => 'value') end get '/hey.json' expect(last_response.status).to eq(403) expect(last_response.headers['X-Custom']).to eq('value') end it 'sets the status code for the endpoint' do memoized_endpoint = nil subject.get '/hey' do memoized_endpoint = self error!({ 'dude' => 'rad' }, 403, 'X-Custom' => 'value') end get '/hey.json' expect(memoized_endpoint.status).to eq(403) end end describe '#redirect' do it 'redirects to a url with status 302' do subject.get('/hey') do redirect '/ha' end get '/hey' expect(last_response.status).to eq 302 expect(last_response.headers['Location']).to eq '/ha' expect(last_response.body).to eq 'This resource has been moved temporarily to /ha.' end it 'has status code 303 if it is not get request and it is http 1.1' do subject.post('/hey') do redirect '/ha' end post '/hey', {}, 'HTTP_VERSION' => 'HTTP/1.1' expect(last_response.status).to eq 303 expect(last_response.headers['Location']).to eq '/ha' expect(last_response.body).to eq 'An alternate resource is located at /ha.' end it 'support permanent redirect' do subject.get('/hey') do redirect '/ha', permanent: true end get '/hey' expect(last_response.status).to eq 301 expect(last_response.headers['Location']).to eq '/ha' expect(last_response.body).to eq 'This resource has been moved permanently to /ha.' end it 'allows for an optional redirect body override' do subject.get('/hey') do redirect '/ha', body: 'test body' end get '/hey' expect(last_response.body).to eq 'test body' end end it 'does not persist params between calls' do subject.post('/new') do params[:text] end post '/new', text: 'abc' expect(last_response.body).to eq('abc') post '/new', text: 'def' expect(last_response.body).to eq('def') end it 'resets all instance variables (except block) between calls' do subject.helpers do def memoized @memoized ||= params[:howdy] end end subject.get('/hello') do memoized end get '/hello?howdy=hey' expect(last_response.body).to eq('hey') get '/hello?howdy=yo' expect(last_response.body).to eq('yo') end it 'allows explicit return calls' do subject.get('/home') do return 'Hello' end get '/home' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello') end describe '.generate_api_method' do it 'raises NameError if the method name is already in use' do expect do Grape::Endpoint.generate_api_method('version', &proc {}) end.to raise_error(NameError) end it 'raises ArgumentError if a block is not given' do expect do Grape::Endpoint.generate_api_method('GET without a block method') end.to raise_error(ArgumentError) end it 'returns a Proc' do expect(Grape::Endpoint.generate_api_method('GET test for a proc', &proc {})).to be_a Proc end end context 'filters' do describe 'before filters' do it 'runs the before filter if set' do subject.before { env['before_test'] = 'OK' } subject.get('/before_test') { env['before_test'] } get '/before_test' expect(last_response.body).to eq('OK') end end describe 'after filters' do it 'overrides the response body if it sets it' do subject.after { body 'after' } subject.get('/after_test') { 'during' } get '/after_test' expect(last_response.body).to eq('after') end it 'does not override the response body with its return' do subject.after { 'after' } subject.get('/after_test') { 'body' } get '/after_test' expect(last_response.body).to eq('body') end end it 'allows adding to response with present' do subject.format :json subject.before { present :before, 'before' } subject.before_validation { present :before_validation, 'before_validation' } subject.after_validation { present :after_validation, 'after_validation' } subject.after { present :after, 'after' } subject.get :all_filters do present :endpoint, 'endpoint' end get '/all_filters' json = JSON.parse(last_response.body) expect(json.keys).to match_array %w(before before_validation after_validation endpoint after) end context 'when terminating the response with error!' do it 'breaks normal call chain' do called = [] subject.before { called << 'before' } subject.before_validation { called << 'before_validation' } subject.after_validation { error! :oops, 500 } subject.after { called << 'after' } subject.get :error_filters do called << 'endpoint' '' end get '/error_filters' expect(last_response.status).to eql 500 expect(called).to match_array %w(before before_validation) end it 'allows prior and parent filters of same type to run' do called = [] subject.before { called << 'parent' } subject.namespace :parent do before { called << 'prior' } before { error! :oops, 500 } before { called << 'subsequent' } get :hello do called << :endpoint 'Hello!' end end get '/parent/hello' expect(last_response.status).to eql 500 expect(called).to match_array %w(parent prior) end end end context 'anchoring' do verbs = %w(post get head delete put options patch) verbs.each do |verb| it "allows for the anchoring option with a #{verb.upcase} method" do subject.send(verb, '/example', anchor: true) do verb end send(verb, '/example/and/some/more') expect(last_response.status).to eql 404 end it "anchors paths by default for the #{verb.upcase} method" do subject.send(verb, '/example') do verb end send(verb, '/example/and/some/more') expect(last_response.status).to eql 404 end it "responds to /example/and/some/more for the non-anchored #{verb.upcase} method" do subject.send(verb, '/example', anchor: false) do verb end send(verb, '/example/and/some/more') expect(last_response.status).to eql verb == 'post' ? 201 : 200 expect(last_response.body).to eql verb == 'head' ? '' : verb end end end context 'request' do it 'is set to the url requested' do subject.get('/url') do request.url end get '/url' expect(last_response.body).to eq('http://example.org/url') end ['v1', :v1].each do |version| it "should include version #{version}" do subject.version version, using: :path subject.get('/url') do request.url end get "/#{version}/url" expect(last_response.body).to eq("http://example.org/#{version}/url") end end it 'should include prefix' do subject.version 'v1', using: :path subject.prefix 'api' subject.get('/url') do request.url end get '/api/v1/url' expect(last_response.body).to eq('http://example.org/api/v1/url') end end context 'version headers' do before do # NOTE: a 404 is returned instead of the 406 if cascade: false is not set. subject.version 'v1', using: :header, vendor: 'ohanapi', cascade: false subject.get '/test' do 'Hello!' end end it 'result in a 406 response if they are invalid' do get '/test', {}, 'HTTP_ACCEPT' => 'application/vnd.ohanapi.v1+json' expect(last_response.status).to eq(406) end it 'result in a 406 response if they cannot be parsed by rack-accept' do get '/test', {}, 'HTTP_ACCEPT' => 'application/vnd.ohanapi.v1+json; version=1' expect(last_response.status).to eq(406) end end context 'binary' do before do subject.get do file FileStreamer.new(__FILE__) end end it 'suports stream objects in response' do get '/' expect(last_response.status).to eq 200 expect(last_response.body).to eq File.read(__FILE__) end end context 'validation errors' do before do subject.before do header['Access-Control-Allow-Origin'] = '*' end subject.params do requires :id, type: String end subject.get do 'should not get here' end end it 'returns the errors, and passes headers' do get '/' expect(last_response.status).to eq 400 expect(last_response.body).to eq 'id is missing' expect(last_response.headers['Access-Control-Allow-Origin']).to eq('*') end end context 'instrumentation' do before do subject.before do # Placeholder end subject.get do 'hello' end @events = [] @subscriber = ActiveSupport::Notifications.subscribe(/grape/) do |*args| @events << ActiveSupport::Notifications::Event.new(*args) end end after do ActiveSupport::Notifications.unsubscribe(@subscriber) end it 'notifies AS::N' do get '/' # In order that the events finalized (time each block ended) expect(@events).to contain_exactly( have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: a_collection_containing_exactly(an_instance_of(Proc)), type: :before }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: [], type: :before_validation }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: [], type: :after_validation }), have_attributes(name: 'endpoint_render.grape', payload: { endpoint: a_kind_of(Grape::Endpoint) }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: [], type: :after }), have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), env: an_instance_of(Hash) }) ) # In order that events were initialized expect(@events.sort_by(&:time)).to contain_exactly( have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), env: an_instance_of(Hash) }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: a_collection_containing_exactly(an_instance_of(Proc)), type: :before }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: [], type: :before_validation }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: [], type: :after_validation }), have_attributes(name: 'endpoint_render.grape', payload: { endpoint: a_kind_of(Grape::Endpoint) }), have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint), filters: [], type: :after }) ) end end end grape-0.16.2/spec/grape/validations/0000755000004100000410000000000012706307017017276 5ustar www-datawww-datagrape-0.16.2/spec/grape/validations/types_spec.rb0000644000004100000410000000421712706307017022005 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::Types do module TypesSpec class FooType def self.parse(_) end end class BarType def self.parse end end end VirtusA = Virtus::Attribute.build(String) module VirtusModule include Virtus.module end class VirtusB include VirtusModule end class VirtusC include Virtus.model end MyAxiom = Axiom::Types::String.new do minimum_length 1 maximum_length 30 end describe '::primitive?' do [ Integer, Float, Numeric, BigDecimal, Virtus::Attribute::Boolean, String, Symbol, Date, DateTime, Time, Rack::Multipart::UploadedFile ].each do |type| it "recognizes #{type} as a primitive" do expect(described_class.primitive?(type)).to be_truthy end end it 'identifies unknown types' do expect(described_class.primitive?(Object)).to be_falsy expect(described_class.primitive?(TypesSpec::FooType)).to be_falsy end end describe '::structure?' do [ Hash, Array, Set ].each do |type| it "recognizes #{type} as a structure" do expect(described_class.structure?(type)).to be_truthy end end end describe '::recognized?' do [ VirtusA, VirtusB, VirtusC, MyAxiom ].each do |type| it "recognizes #{type}" do expect(described_class.recognized?(type)).to be_truthy end end end describe '::special?' do [ JSON, Array[JSON], File, Rack::Multipart::UploadedFile ].each do |type| it "provides special handling for #{type.inspect}" do expect(described_class.special?(type)).to be_truthy end end end describe '::custom?' do it 'returns false if the type does not respond to :parse' do expect(described_class.custom?(Object)).to be_falsy end it 'returns true if the type responds to :parse with one argument' do expect(described_class.custom?(TypesSpec::FooType)).to be_truthy end it 'returns false if the type\'s #parse method takes other than one argument' do expect(described_class.custom?(TypesSpec::BarType)).to be_falsy end end end grape-0.16.2/spec/grape/validations/params_scope_spec.rb0000644000004100000410000002635212706307017023321 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::ParamsScope do subject do Class.new(Grape::API) end def app subject end context 'setting a default' do let(:documentation) { subject.routes.first.params } context 'when the default value is truthy' do before do subject.params do optional :int, type: Integer, default: 42 end subject.get end it 'adds documentation about the default value' do expect(documentation).to have_key('int') expect(documentation['int']).to have_key(:default) expect(documentation['int'][:default]).to eq(42) end end context 'when the default value is false' do before do subject.params do optional :bool, type: Virtus::Attribute::Boolean, default: false end subject.get end it 'adds documentation about the default value' do expect(documentation).to have_key('bool') expect(documentation['bool']).to have_key(:default) expect(documentation['bool'][:default]).to eq(false) end end context 'when the default value is nil' do before do subject.params do optional :object, type: Object, default: nil end subject.get end it 'adds documentation about the default value' do expect(documentation).to have_key('object') expect(documentation['object']).to have_key(:default) expect(documentation['object'][:default]).to eq(nil) end end end context 'without a default' do before do subject.params do optional :object, type: Object end subject.get end it 'does not add documentation for the default value' do documentation = subject.routes.first.params expect(documentation).to have_key('object') expect(documentation['object']).not_to have_key(:default) end end context 'setting description' do [:desc, :description].each do |description_type| it "allows setting #{description_type}" do subject.params do requires :int, type: Integer, description_type => 'My very nice integer' end subject.get '/single' do 'int works' end get '/single', int: 420 expect(last_response.status).to eq(200) expect(last_response.body).to eq('int works') end end end context 'when using custom types' do module ParamsScopeSpec class CustomType attr_reader :value def self.parse(value) fail if value == 'invalid' new(value) end def initialize(value) @value = value end end end it 'coerces the parameter via the type\'s parse method' do subject.params do requires :foo, type: ParamsScopeSpec::CustomType end subject.get('/types') { params[:foo].value } get '/types', foo: 'valid' expect(last_response.status).to eq(200) expect(last_response.body).to eq('valid') get '/types', foo: 'invalid' expect(last_response.status).to eq(400) expect(last_response.body).to match(/foo is invalid/) end end context 'array without coerce type explicitly given' do it 'sets the type based on first element' do subject.params do requires :periods, type: Array, values: -> { %w(day month) } end subject.get('/required') { 'required works' } get '/required', periods: %w(day month) expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end it 'fails to call API without Array type' do subject.params do requires :periods, type: Array, values: -> { %w(day month) } end subject.get('/required') { 'required works' } get '/required', periods: 'day' expect(last_response.status).to eq(400) expect(last_response.body).to eq('periods is invalid') end it 'raises exception when values are of different type' do expect do subject.params { requires :numbers, type: Array, values: [1, 'definitely not a number', 3] } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end it 'raises exception when range values have different endpoint types' do expect do subject.params { requires :numbers, type: Array, values: 0.0..10 } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end end context 'with range values' do context "when left range endpoint isn't #kind_of? the type" do it 'raises exception' do expect do subject.params { requires :latitude, type: Integer, values: -90.0..90 } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end end context "when right range endpoint isn't #kind_of? the type" do it 'raises exception' do expect do subject.params { requires :latitude, type: Integer, values: -90..90.0 } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end end context 'when the default is an array' do context 'and is the entire range of allowed values' do it 'does not raise an exception' do expect do subject.params { optional :numbers, type: Array[Integer], values: 0..2, default: 0..2 } end.to_not raise_error end end context 'and is a subset of allowed values' do it 'does not raise an exception' do expect do subject.params { optional :numbers, type: Array[Integer], values: [0, 1, 2], default: [1, 0] } end.to_not raise_error end end end context 'when both range endpoints are #kind_of? the type' do it 'accepts values in the range' do subject.params do requires :letter, type: String, values: 'a'..'z' end subject.get('/letter') { params[:letter] } get '/letter', letter: 'j' expect(last_response.status).to eq(200) expect(last_response.body).to eq('j') end it 'rejects values outside the range' do subject.params do requires :letter, type: String, values: 'a'..'z' end subject.get('/letter') { params[:letter] } get '/letter', letter: 'J' expect(last_response.status).to eq(400) expect(last_response.body).to eq('letter does not have a valid value') end end end context 'parameters in group' do it 'errors when no type is provided' do expect do subject.params do group :a do requires :b end end end.to raise_error Grape::Exceptions::MissingGroupTypeError expect do subject.params do optional :a do requires :b end end end.to raise_error Grape::Exceptions::MissingGroupTypeError end it 'allows Hash as type' do subject.params do group :a, type: Hash do requires :b end end subject.get('/group') { 'group works' } get '/group', a: { b: true } expect(last_response.status).to eq(200) expect(last_response.body).to eq('group works') subject.params do optional :a, type: Hash do requires :b end end get '/optional_type_hash' end it 'allows Array as type' do subject.params do group :a, type: Array do requires :b end end subject.get('/group') { 'group works' } get '/group', a: [{ b: true }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('group works') subject.params do optional :a, type: Array do requires :b end end get '/optional_type_array' end it 'errors with an unsupported type' do expect do subject.params do group :a, type: Set do requires :b end end end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError expect do subject.params do optional :a, type: Set do requires :b end end end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError end end context 'when validations are dependent on a parameter' do before do subject.params do optional :a given :a do requires :b end end subject.get('/test') { declared(params).to_json } end it 'applies the validations only if the parameter is present' do get '/test' expect(last_response.status).to eq(200) get '/test', a: true expect(last_response.status).to eq(400) expect(last_response.body).to eq('b is missing') get '/test', a: true, b: true expect(last_response.status).to eq(200) end it 'applies the validations of multiple parameters' do subject.params do optional :a, :b given :a, :b do requires :c end end subject.get('/multiple') { declared(params).to_json } get '/multiple' expect(last_response.status).to eq(200) get '/multiple', a: true expect(last_response.status).to eq(200) get '/multiple', b: true expect(last_response.status).to eq(200) get '/multiple', a: true, b: true expect(last_response.status).to eq(400) expect(last_response.body).to eq('c is missing') get '/multiple', a: true, b: true, c: true expect(last_response.status).to eq(200) end it 'raises an error if the dependent parameter was never specified' do expect do subject.params do given :c do end end end.to raise_error(Grape::Exceptions::UnknownParameter) end it 'includes the parameter within #declared(params)' do get '/test', a: true, b: true expect(JSON.parse(last_response.body)).to eq('a' => 'true', 'b' => 'true') end it 'returns a sensible error message within a nested context' do subject.params do requires :bar, type: Hash do optional :a given :a do requires :b end end end subject.get('/nested') { 'worked' } get '/nested', bar: { a: true } expect(last_response.status).to eq(400) expect(last_response.body).to eq('bar[b] is missing') end it 'includes the nested parameter within #declared(params)' do subject.params do requires :bar, type: Hash do optional :a given :a do requires :b end end end subject.get('/nested') { declared(params).to_json } get '/nested', bar: { a: true, b: 'yes' } expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'true', 'b' => 'yes' }) end it 'includes level 2 nested parameters outside the given within #declared(params)' do subject.params do requires :bar, type: Hash do optional :a given :a do requires :c, type: Hash do requires :b end end end end subject.get('/nested') { declared(params).to_json } get '/nested', bar: { a: true, c: { b: 'yes' } } expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'true', 'c' => { 'b' => 'yes' } }) end end end grape-0.16.2/spec/grape/validations/attributes_iterator_spec.rb0000644000004100000410000000011612706307017024732 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::AttributesIterator do end grape-0.16.2/spec/grape/validations/validators/0000755000004100000410000000000012706307017021446 5ustar www-datawww-datagrape-0.16.2/spec/grape/validations/validators/exactly_one_of_spec.rb0000644000004100000410000000416612706307017026012 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::ExactlyOneOfValidator do describe '#validate!' do let(:scope) do Struct.new(:opts) do def params(arg) arg end def required?; end end end let(:exactly_one_of_params) { [:beer, :wine, :grapefruit] } let(:validator) { described_class.new(exactly_one_of_params, {}, false, scope.new) } context 'when all restricted params are present' do let(:params) { { beer: true, wine: true, grapefruit: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end context 'mixed with other params' do let(:mixed_params) { params.merge!(other: true, andanother: true) } it 'still raises a validation exception' do expect do validator.validate! mixed_params end.to raise_error(Grape::Exceptions::Validation) end end end context 'when a subset of restricted params are present' do let(:params) { { beer: true, grapefruit: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end context 'when params keys come as strings' do let(:params) { { 'beer' => true, 'grapefruit' => true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end context 'when none of the restricted params is selected' do let(:params) { { somethingelse: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end context 'when exactly one of the restricted params is selected' do let(:params) { { beer: true, somethingelse: true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end end end end grape-0.16.2/spec/grape/validations/validators/coerce_spec.rb0000644000004100000410000005357012706307017024257 0ustar www-datawww-data# encoding: utf-8 require 'spec_helper' describe Grape::Validations::CoerceValidator do subject do Class.new(Grape::API) end def app subject end describe 'coerce' do module CoerceValidatorSpec class User include Virtus.model attribute :id, Integer attribute :name, String end end context 'i18n' do after :each do I18n.locale = :en end it 'i18n error on malformed input' do I18n.load_path << File.expand_path('../zh-CN.yml', __FILE__) I18n.reload! I18n.locale = 'zh-CN'.to_sym subject.params do requires :age, type: Integer end subject.get '/single' do 'int works' end get '/single', age: '43a' expect(last_response.status).to eq(400) expect(last_response.body).to eq('年龄格å¼ä¸æ­£ç¡®') end it 'gives an english fallback error when default locale message is blank' do I18n.locale = 'pt-BR'.to_sym subject.params do requires :age, type: Integer end subject.get '/single' do 'int works' end get '/single', age: '43a' expect(last_response.status).to eq(400) expect(last_response.body).to eq('age is invalid') end end context 'with a custom validation message' do it 'errors on malformed input' do subject.params do requires :int, type: { value: Integer, message: 'type cast is invalid' } end subject.get '/single' do 'int works' end get '/single', int: '43a' expect(last_response.status).to eq(400) expect(last_response.body).to eq('int type cast is invalid') get '/single', int: '43' expect(last_response.status).to eq(200) expect(last_response.body).to eq('int works') end context 'on custom coercion rules' do before do subject.params do requires :a, types: { value: [Boolean, String], message: 'type cast is invalid' }, coerce_with: (lambda do |val| if val == 'yup' true elsif val == 'false' 0 else val end end) end subject.get '/' do params[:a].class.to_s end end it 'respects :coerce_with' do get '/', a: 'yup' expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') end it 'still validates type' do get '/', a: 'false' expect(last_response.status).to eq(400) expect(last_response.body).to eq('a type cast is invalid') end it 'performs no additional coercion' do get '/', a: 'true' expect(last_response.status).to eq(200) expect(last_response.body).to eq('String') end end end it 'error on malformed input' do subject.params do requires :int, type: Integer end subject.get '/single' do 'int works' end get '/single', int: '43a' expect(last_response.status).to eq(400) expect(last_response.body).to eq('int is invalid') get '/single', int: '43' expect(last_response.status).to eq(200) expect(last_response.body).to eq('int works') end it 'error on malformed input (Array)' do subject.params do requires :ids, type: Array[Integer] end subject.get '/array' do 'array int works' end get 'array', ids: %w(1 2 az) expect(last_response.status).to eq(400) expect(last_response.body).to eq('ids is invalid') get 'array', ids: %w(1 2 890) expect(last_response.status).to eq(200) expect(last_response.body).to eq('array int works') end context 'complex objects' do it 'error on malformed input for complex objects' do subject.params do requires :user, type: CoerceValidatorSpec::User end subject.get '/user' do 'complex works' end get '/user', user: '32' expect(last_response.status).to eq(400) expect(last_response.body).to eq('user is invalid') get '/user', user: { id: 32, name: 'Bob' } expect(last_response.status).to eq(200) expect(last_response.body).to eq('complex works') end end context 'coerces' do it 'Integer' do subject.params do requires :int, coerce: Integer end subject.get '/int' do params[:int].class end get '/int', int: '45' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum') end context 'Array' do it 'Array of Integers' do subject.params do requires :arry, coerce: Array[Integer] end subject.get '/array' do params[:arry][0].class end get '/array', arry: %w(1 2 3) expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum') end it 'Array of Bools' do subject.params do requires :arry, coerce: Array[Virtus::Attribute::Boolean] end subject.get '/array' do params[:arry][0].class end get 'array', arry: [1, 0] expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') end it 'Array of Complex' do subject.params do requires :arry, coerce: Array[CoerceValidatorSpec::User] end subject.get '/array' do params[:arry].size end get 'array', arry: [31] expect(last_response.status).to eq(400) expect(last_response.body).to eq('arry is invalid') get 'array', arry: { id: 31, name: 'Alice' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('arry is invalid') get 'array', arry: [{ id: 31, name: 'Alice' }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('1') end end context 'Set' do it 'Set of Integers' do subject.params do requires :set, coerce: Set[Integer] end subject.get '/set' do params[:set].first.class end get '/set', set: Set.new([1, 2, 3, 4]).to_a expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum') end it 'Set of Bools' do subject.params do requires :set, coerce: Set[Virtus::Attribute::Boolean] end subject.get '/set' do params[:set].first.class end get '/set', set: Set.new([1, 0]).to_a expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') end end it 'Bool' do subject.params do requires :bool, coerce: Virtus::Attribute::Boolean end subject.get '/bool' do params[:bool].class end get '/bool', bool: 1 expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') get '/bool', bool: 0 expect(last_response.status).to eq(200) expect(last_response.body).to eq('FalseClass') get '/bool', bool: 'false' expect(last_response.status).to eq(200) expect(last_response.body).to eq('FalseClass') get '/bool', bool: 'true' expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') end it 'Rack::Multipart::UploadedFile' do subject.params do requires :file, type: Rack::Multipart::UploadedFile end subject.post '/upload' do params[:file].filename end post '/upload', file: Rack::Test::UploadedFile.new(__FILE__) expect(last_response.status).to eq(201) expect(last_response.body).to eq(File.basename(__FILE__).to_s) post '/upload', file: 'not a file' expect(last_response.status).to eq(400) expect(last_response.body).to eq('file is invalid') end it 'File' do subject.params do requires :file, coerce: File end subject.post '/upload' do params[:file].filename end post '/upload', file: Rack::Test::UploadedFile.new(__FILE__) expect(last_response.status).to eq(201) expect(last_response.body).to eq(File.basename(__FILE__).to_s) post '/upload', file: 'not a file' expect(last_response.status).to eq(400) expect(last_response.body).to eq('file is invalid') end it 'Nests integers' do subject.params do requires :integers, type: Hash do requires :int, coerce: Integer end end subject.get '/int' do params[:integers][:int].class end get '/int', integers: { int: '45' } expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum') end end context 'using coerce_with' do it 'parses parameters with Array type' do subject.params do requires :values, type: Array, coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) } end subject.get '/ints' do params[:values] end get '/ints', values: '1 2 3 4' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq([1, 2, 3, 4]) get '/ints', values: 'a b c d' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq([0, 0, 0, 0]) end it 'parses parameters with Array[String] type' do subject.params do requires :values, type: Array[String], coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) } end subject.get '/ints' do params[:values] end get '/ints', values: '1 2 3 4' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq(%w(1 2 3 4)) get '/ints', values: 'a b c d' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq(%w(0 0 0 0)) end it 'parses parameters with Array[Integer] type' do subject.params do requires :values, type: Array[Integer], coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) } end subject.get '/ints' do params[:values] end get '/ints', values: '1 2 3 4' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq([1, 2, 3, 4]) get '/ints', values: 'a b c d' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq([0, 0, 0, 0]) end it 'uses parse where available' do subject.params do requires :ints, type: Array, coerce_with: JSON do requires :i, type: Integer requires :j end end subject.get '/ints' do ints = params[:ints].first 'coercion works' if ints[:i] == 1 && ints[:j] == '2' end get '/ints', ints: [{ i: 1, j: '2' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('ints is invalid') get '/ints', ints: '{"i":1,"j":"2"}' expect(last_response.status).to eq(400) expect(last_response.body).to eq('ints[0][i] is missing, ints[0][i] is invalid, ints[0][j] is missing') get '/ints', ints: '[{"i":"1","j":"2"}]' expect(last_response.status).to eq(200) expect(last_response.body).to eq('coercion works') end it 'accepts any callable' do subject.params do requires :ints, type: Hash, coerce_with: JSON.method(:parse) do requires :int, type: Integer, coerce_with: ->(val) { val == 'three' ? 3 : val } end end subject.get '/ints' do params[:ints][:int] end get '/ints', ints: '{"int":"3"}' expect(last_response.status).to eq(400) expect(last_response.body).to eq('ints[int] is invalid') get '/ints', ints: '{"int":"three"}' expect(last_response.status).to eq(200) expect(last_response.body).to eq('3') get '/ints', ints: '{"int":3}' expect(last_response.status).to eq(200) expect(last_response.body).to eq('3') end it 'must be supplied with :type or :coerce' do expect do subject.params do requires :ints, coerce_with: JSON end end.to raise_error(ArgumentError) end end context 'first-class JSON' do it 'parses objects and arrays' do subject.params do requires :splines, type: JSON do requires :x, type: Integer, values: [1, 2, 3] optional :ints, type: Array[Integer] optional :obj, type: Hash do optional :y end end end subject.get '/' do if params[:splines].is_a? Hash params[:splines][:obj][:y] else 'arrays work' if params[:splines].any? { |s| s.key? :obj } end end get '/', splines: '{"x":1,"ints":[1,2,3],"obj":{"y":"woof"}}' expect(last_response.status).to eq(200) expect(last_response.body).to eq('woof') get '/', splines: '[{"x":2,"ints":[]},{"x":3,"ints":[4],"obj":{"y":"quack"}}]' expect(last_response.status).to eq(200) expect(last_response.body).to eq('arrays work') get '/', splines: '{"x":4,"ints":[2]}' expect(last_response.status).to eq(400) expect(last_response.body).to eq('splines[x] does not have a valid value') get '/', splines: '[{"x":1,"ints":[]},{"x":4,"ints":[]}]' expect(last_response.status).to eq(400) expect(last_response.body).to eq('splines[x] does not have a valid value') end it 'works when declared optional' do subject.params do optional :splines, type: JSON do requires :x, type: Integer, values: [1, 2, 3] optional :ints, type: Array[Integer] optional :obj, type: Hash do optional :y end end end subject.get '/' do if params[:splines].is_a? Hash params[:splines][:obj][:y] else 'arrays work' if params[:splines].any? { |s| s.key? :obj } end end get '/', splines: '{"x":1,"ints":[1,2,3],"obj":{"y":"woof"}}' expect(last_response.status).to eq(200) expect(last_response.body).to eq('woof') get '/', splines: '[{"x":2,"ints":[]},{"x":3,"ints":[4],"obj":{"y":"quack"}}]' expect(last_response.status).to eq(200) expect(last_response.body).to eq('arrays work') get '/', splines: '{"x":4,"ints":[2]}' expect(last_response.status).to eq(400) expect(last_response.body).to eq('splines[x] does not have a valid value') get '/', splines: '[{"x":1,"ints":[]},{"x":4,"ints":[]}]' expect(last_response.status).to eq(400) expect(last_response.body).to eq('splines[x] does not have a valid value') end it 'accepts Array[JSON] shorthand' do subject.params do requires :splines, type: Array[JSON] do requires :x, type: Integer, values: [1, 2, 3] requires :y end end subject.get '/' do params[:splines].first[:y].class.to_s spline = params[:splines].first "#{spline[:x].class}.#{spline[:y].class}" end get '/', splines: '{"x":"1","y":"woof"}' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum.String') get '/', splines: '[{"x":1,"y":2},{"x":1,"y":"quack"}]' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum.Fixnum') get '/', splines: '{"x":"4","y":"woof"}' expect(last_response.status).to eq(400) expect(last_response.body).to eq('splines[x] does not have a valid value') get '/', splines: '[{"x":"4","y":"woof"}]' expect(last_response.status).to eq(400) expect(last_response.body).to eq('splines[x] does not have a valid value') end it "doesn't make sense using coerce_with" do expect do subject.params do requires :bad, type: JSON, coerce_with: JSON do requires :x end end end.to raise_error(ArgumentError) expect do subject.params do requires :bad, type: Array[JSON], coerce_with: JSON do requires :x end end end.to raise_error(ArgumentError) end end context 'multiple types' do Boolean = Grape::API::Boolean it 'coerces to first possible type' do subject.params do requires :a, types: [Boolean, Integer, String] end subject.get '/' do params[:a].class.to_s end get '/', a: 'true' expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') get '/', a: '5' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Fixnum') get '/', a: 'anything else' expect(last_response.status).to eq(200) expect(last_response.body).to eq('String') end it 'fails when no coercion is possible' do subject.params do requires :a, types: [Boolean, Integer] end subject.get '/' do params[:a].class.to_s end get '/', a: true expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') get '/', a: 'not good' expect(last_response.status).to eq(400) expect(last_response.body).to eq('a is invalid') end context 'for primitive collections' do before do subject.params do optional :a, types: [String, Array[String]] optional :b, types: [Array[Integer], Array[String]] optional :c, type: Array[Integer, String] optional :d, types: [Integer, String, Set[Integer, String]] end subject.get '/' do ( params[:a] || params[:b] || params[:c] || params[:d] ).inspect end end it 'allows singular form declaration' do get '/', a: 'one way' expect(last_response.status).to eq(200) expect(last_response.body).to eq('"one way"') get '/', a: %w(the other) expect(last_response.status).to eq(200) expect(last_response.body).to eq('["the", "other"]') get '/', a: { a: 1, b: 2 } expect(last_response.status).to eq(400) expect(last_response.body).to eq('a is invalid') get '/', a: [1, 2, 3] expect(last_response.status).to eq(200) expect(last_response.body).to eq('["1", "2", "3"]') end it 'allows multiple collection types' do get '/', b: [1, 2, 3] expect(last_response.status).to eq(200) expect(last_response.body).to eq('[1, 2, 3]') get '/', b: %w(1 2 3) expect(last_response.status).to eq(200) expect(last_response.body).to eq('[1, 2, 3]') get '/', b: [1, true, 'three'] expect(last_response.status).to eq(200) expect(last_response.body).to eq('["1", "true", "three"]') end it 'allows collections with multiple types' do get '/', c: [1, '2', true, 'three'] expect(last_response.status).to eq(200) expect(last_response.body).to eq('[1, 2, "true", "three"]') get '/', d: '1' expect(last_response.status).to eq(200) expect(last_response.body).to eq('1') get '/', d: 'one' expect(last_response.status).to eq(200) expect(last_response.body).to eq('"one"') get '/', d: %w(1 two) expect(last_response.status).to eq(200) expect(last_response.body).to eq('#') end end context 'custom coercion rules' do before do subject.params do requires :a, types: [Boolean, String], coerce_with: (lambda do |val| if val == 'yup' true elsif val == 'false' 0 else val end end) end subject.get '/' do params[:a].class.to_s end end it 'respects :coerce_with' do get '/', a: 'yup' expect(last_response.status).to eq(200) expect(last_response.body).to eq('TrueClass') end it 'still validates type' do get '/', a: 'false' expect(last_response.status).to eq(400) expect(last_response.body).to eq('a is invalid') end it 'performs no additional coercion' do get '/', a: 'true' expect(last_response.status).to eq(200) expect(last_response.body).to eq('String') end end it 'may not be supplied together with a single type' do expect do subject.params do requires :a, type: Integer, types: [Integer, String] end end.to raise_exception ArgumentError end end context 'converter' do it 'does not build Virtus::Attribute multiple times' do subject.params do requires :something, type: Array[String] end subject.get do end expect(Virtus::Attribute).to receive(:build).at_most(2).times.and_call_original 10.times { get '/' } end end end end grape-0.16.2/spec/grape/validations/validators/default_spec.rb0000644000004100000410000001667412706307017024447 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::DefaultValidator do module ValidationsSpec module DefaultValidatorSpec class API < Grape::API default_format :json params do optional :id optional :type, default: 'default-type' end get '/' do { id: params[:id], type: params[:type] } end params do optional :type1, default: 'default-type1' optional :type2, default: 'default-type2' end get '/user' do { type1: params[:type1], type2: params[:type2] } end params do requires :id optional :type1, default: 'default-type1' optional :type2, default: 'default-type2' end get '/message' do { id: params[:id], type1: params[:type1], type2: params[:type2] } end params do optional :random, default: -> { Random.rand } optional :not_random, default: Random.rand end get '/numbers' do { random_number: params[:random], non_random_number: params[:non_random_number] } end params do optional :array, type: Array do requires :name optional :with_default, default: 'default' end end get '/array' do { array: params[:array] } end end end end def app ValidationsSpec::DefaultValidatorSpec::API end it 'set default value for optional param' do get('/') expect(last_response.status).to eq(200) expect(last_response.body).to eq({ id: nil, type: 'default-type' }.to_json) end it 'set default values for optional params' do get('/user') expect(last_response.status).to eq(200) expect(last_response.body).to eq({ type1: 'default-type1', type2: 'default-type2' }.to_json) end it 'set default values for missing params in the request' do get('/user?type2=value2') expect(last_response.status).to eq(200) expect(last_response.body).to eq({ type1: 'default-type1', type2: 'value2' }.to_json) end it 'set default values for optional params and allow to use required fields in the same time' do get('/message?id=1') expect(last_response.status).to eq(200) expect(last_response.body).to eq({ id: '1', type1: 'default-type1', type2: 'default-type2' }.to_json) end it 'sets lambda based defaults at the time of call' do get('/numbers') expect(last_response.status).to eq(200) before = JSON.parse(last_response.body) get('/numbers') expect(last_response.status).to eq(200) after = JSON.parse(last_response.body) expect(before['non_random_number']).to eq(after['non_random_number']) expect(before['random_number']).not_to eq(after['random_number']) end it 'sets default values for grouped arrays' do get('/array?array[][name]=name&array[][name]=name2&array[][with_default]=bar2') expect(last_response.status).to eq(200) expect(last_response.body).to eq({ array: [{ name: 'name', with_default: 'default' }, { name: 'name2', with_default: 'bar2' }] }.to_json) end context 'optional group with defaults' do subject do Class.new(Grape::API) do default_format :json end end def app subject end context 'optional array without default value includes optional param with default value' do before do subject.params do optional :optional_array, type: Array do optional :foo_in_optional_array, default: 'bar' end end subject.post '/optional_array' do { optional_array: params[:optional_array] } end end it 'returns nil for optional array if param is not provided' do post '/optional_array' expect(last_response.status).to eq(201) expect(last_response.body).to eq({ optional_array: nil }.to_json) end end context 'optional array with default value includes optional param with default value' do before do subject.params do optional :optional_array_with_default, type: Array, default: [] do optional :foo_in_optional_array, default: 'bar' end end subject.post '/optional_array_with_default' do { optional_array_with_default: params[:optional_array_with_default] } end end it 'sets default value for optional array if param is not provided' do post '/optional_array_with_default' expect(last_response.status).to eq(201) expect(last_response.body).to eq({ optional_array_with_default: [] }.to_json) end end context 'optional hash without default value includes optional param with default value' do before do subject.params do optional :optional_hash_without_default, type: Hash do optional :foo_in_optional_hash, default: 'bar' end end subject.post '/optional_hash_without_default' do { optional_hash_without_default: params[:optional_hash_without_default] } end end it 'returns nil for optional hash if param is not provided' do post '/optional_hash_without_default' expect(last_response.status).to eq(201) expect(last_response.body).to eq({ optional_hash_without_default: nil }.to_json) end it 'does not fail even if invalid params is passed to default validator' do expect { post '/optional_hash_without_default', optional_hash_without_default: '5678' }.not_to raise_error expect(last_response.status).to eq(400) expect(last_response.body).to eq({ error: 'optional_hash_without_default is invalid' }.to_json) end end context 'optional hash with default value includes optional param with default value' do before do subject.params do optional :optional_hash_with_default, type: Hash, default: {} do optional :foo_in_optional_hash, default: 'bar' end end subject.post '/optional_hash_with_default_empty_hash' do { optional_hash_with_default: params[:optional_hash_with_default] } end subject.params do optional :optional_hash_with_default, type: Hash, default: { foo_in_optional_hash: 'parent_default' } do optional :some_param optional :foo_in_optional_hash, default: 'own_default' end end subject.post '/optional_hash_with_default_inner_params' do { foo_in_optional_hash: params[:optional_hash_with_default][:foo_in_optional_hash] } end end it 'sets default value for optional hash if param is not provided' do post '/optional_hash_with_default_empty_hash' expect(last_response.status).to eq(201) expect(last_response.body).to eq({ optional_hash_with_default: {} }.to_json) end it 'sets default value from parent defaults for inner param if parent param is not provided' do post '/optional_hash_with_default_inner_params' expect(last_response.status).to eq(201) expect(last_response.body).to eq({ foo_in_optional_hash: 'parent_default' }.to_json) end it 'sets own default value for inner param if parent param is provided' do post '/optional_hash_with_default_inner_params', optional_hash_with_default: { some_param: 'param' } expect(last_response.status).to eq(201) expect(last_response.body).to eq({ foo_in_optional_hash: 'own_default' }.to_json) end end end end grape-0.16.2/spec/grape/validations/validators/at_least_one_of_spec.rb0000644000004100000410000000367012706307017026134 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::AtLeastOneOfValidator do describe '#validate!' do let(:scope) do Struct.new(:opts) do def params(arg) arg end def required?; end end end let(:at_least_one_of_params) { [:beer, :wine, :grapefruit] } let(:validator) { described_class.new(at_least_one_of_params, {}, false, scope.new) } context 'when all restricted params are present' do let(:params) { { beer: true, wine: true, grapefruit: true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end context 'mixed with other params' do let(:mixed_params) { params.merge!(other: true, andanother: true) } it 'does not raise a validation exception' do expect(validator.validate!(mixed_params)).to eql mixed_params end end end context 'when a subset of restricted params are present' do let(:params) { { beer: true, grapefruit: true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end end context 'when params keys come as strings' do let(:params) { { 'beer' => true, 'grapefruit' => true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end end context 'when none of the restricted params is selected' do let(:params) { { somethingelse: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end context 'when exactly one of the restricted params is selected' do let(:params) { { beer: true, somethingelse: true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end end end end grape-0.16.2/spec/grape/validations/validators/zh-CN.yml0000644000004100000410000000033612706307017023112 0ustar www-datawww-datazh-CN: grape: errors: format: ! '%{attributes}%{message}' attributes: age: 年龄 messages: coerce: 'æ ¼å¼ä¸æ­£ç¡®' presence: '请填写' regexp: 'æ ¼å¼ä¸æ­£ç¡®' grape-0.16.2/spec/grape/validations/validators/presence_spec.rb0000644000004100000410000001733112706307017024616 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::PresenceValidator do subject do Class.new(Grape::API) do format :json end end def app subject end context 'without validation' do before do subject.resource :bacons do get do 'All the bacon' end end end it 'does not validate for any params' do get '/bacons' expect(last_response.status).to eq(200) expect(last_response.body).to eq('All the bacon'.to_json) end end context 'with a custom validation message' do before do subject.resource :requires do params do requires :email, type: String, allow_blank: { value: false, message: 'has no value' }, regexp: { value: /^\S+$/, message: 'format is invalid' }, message: 'is required' end get do 'Hello' end end end it 'requires when missing' do get '/requires' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"email is required, email has no value"}') end it 'requires when empty' do get '/requires', email: '' expect(last_response.body).to eq('{"error":"email has no value, email format is invalid"}') end it 'valid when set' do get '/requires', email: 'bob@example.com' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello'.to_json) end end context 'with a required regexp parameter supplied in the POST body' do before do subject.format :json subject.params do requires :id, regexp: /^[0-9]+$/ end subject.post do { ret: params[:id] } end end it 'validates id' do post '/' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"id is missing"}') io = StringIO.new('{"id" : "a56b"}') post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length expect(last_response.body).to eq('{"error":"id is invalid"}') expect(last_response.status).to eq(400) io = StringIO.new('{"id" : 56}') post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length expect(last_response.body).to eq('{"ret":56}') expect(last_response.status).to eq(201) end end context 'with a required non-empty string' do before do subject.params do requires :email, type: String, allow_blank: false, regexp: /^\S+$/ end subject.get do 'Hello' end end it 'requires when missing' do get '/' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"email is missing, email is empty"}') end it 'requires when empty' do get '/', email: '' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"email is empty, email is invalid"}') end it 'valid when set' do get '/', email: 'bob@example.com' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello'.to_json) end end context 'with required parameters and no type' do before do subject.params do requires :name, :company end subject.get do 'Hello' end end it 'validates name, company' do get '/' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"name is missing"}') get '/', name: 'Bob' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"company is missing"}') get '/', name: 'Bob', company: 'TestCorp' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello'.to_json) end end context 'with nested parameters' do before do subject.params do requires :user, type: Hash do requires :first_name requires :last_name end end subject.get '/nested' do 'Nested' end end it 'validates nested parameters' do get '/nested' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user is missing, user[first_name] is missing, user[last_name] is missing"}') get '/nested', user: { first_name: 'Billy' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user[last_name] is missing"}') get '/nested', user: { first_name: 'Billy', last_name: 'Bob' } expect(last_response.status).to eq(200) expect(last_response.body).to eq('Nested'.to_json) end end context 'with triply nested required parameters' do before do subject.params do requires :admin, type: Hash do requires :admin_name requires :super, type: Hash do requires :user, type: Hash do requires :first_name requires :last_name end end end end subject.get '/nested_triple' do 'Nested triple' end end it 'validates triple nested parameters' do get '/nested_triple' expect(last_response.status).to eq(400) expect(last_response.body).to include '{"error":"admin is missing' get '/nested_triple', user: { first_name: 'Billy' } expect(last_response.status).to eq(400) expect(last_response.body).to include '{"error":"admin is missing' get '/nested_triple', admin: { super: { first_name: 'Billy' } } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user] is missing, admin[super][user][first_name] is missing, admin[super][user][last_name] is missing"}') get '/nested_triple', super: { user: { first_name: 'Billy', last_name: 'Bob' } } expect(last_response.status).to eq(400) expect(last_response.body).to include '{"error":"admin is missing' get '/nested_triple', admin: { super: { user: { first_name: 'Billy' } } } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user][last_name] is missing"}') get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: 'Billy' } } } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"admin[super][user][last_name] is missing"}') get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: 'Billy', last_name: 'Bob' } } } expect(last_response.status).to eq(200) expect(last_response.body).to eq('Nested triple'.to_json) end end context 'with reused parameter documentation once required and once optional' do before do docs = { name: { type: String, desc: 'some name' } } subject.params do requires :all, using: docs end subject.get '/required' do 'Hello required' end subject.params do optional :all, using: docs end subject.get '/optional' do 'Hello optional' end end it 'works with required' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"name is missing"}') get '/required', name: 'Bob' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello required'.to_json) end it 'works with optional' do get '/optional' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello optional'.to_json) get '/optional', name: 'Bob' expect(last_response.status).to eq(200) expect(last_response.body).to eq('Hello optional'.to_json) end end end grape-0.16.2/spec/grape/validations/validators/values_spec.rb0000644000004100000410000002417712706307017024317 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::ValuesValidator do module ValidationsSpec class ValuesModel DEFAULT_VALUES = ['valid-type1', 'valid-type2', 'valid-type3'] class << self def values @values ||= [] [DEFAULT_VALUES + @values].flatten.uniq end def add_value(value) @values ||= [] @values << value end end end module ValuesValidatorSpec class API < Grape::API default_format :json resources :custom_message do params do requires :type, values: { value: ValuesModel.values, message: 'value does not include in values' } end get '/' do { type: params[:type] } end params do optional :type, values: { value: -> { ValuesModel.values }, message: 'value does not include in values' }, default: 'valid-type2' end get '/lambda' do { type: params[:type] } end end params do requires :type, values: ValuesModel.values end get '/' do { type: params[:type] } end params do optional :type, values: ValuesModel.values, default: 'valid-type2' end get '/default/valid' do { type: params[:type] } end params do optional :type, values: -> { ValuesModel.values }, default: 'valid-type2' end get '/lambda' do { type: params[:type] } end params do optional :type, values: ValuesModel.values, default: -> { ValuesModel.values.sample } end get '/default_lambda' do { type: params[:type] } end params do optional :type, values: -> { ValuesModel.values }, default: -> { ValuesModel.values.sample } end get '/default_and_values_lambda' do { type: params[:type] } end params do optional :type, type: Boolean, desc: 'A boolean', values: [true] end get '/values/optional_boolean' do { type: params[:type] } end params do requires :type, type: Integer, desc: 'An integer', values: [10, 11], default: 10 end get '/values/coercion' do { type: params[:type] } end params do requires :type, type: Array[Integer], desc: 'An integer', values: [10, 11], default: 10 end get '/values/array_coercion' do { type: params[:type] } end params do optional :optional, type: Array do requires :type, values: %w(a b) end end get '/optional_with_required_values' end end end def app ValidationsSpec::ValuesValidatorSpec::API end context 'with a custom validation message' do it 'allows a valid value for a parameter' do get('/custom_message', type: 'valid-type1') expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 'valid-type1' }.to_json) end it 'does not allow an invalid value for a parameter' do get('/custom_message', type: 'invalid-type') expect(last_response.status).to eq 400 expect(last_response.body).to eq({ error: 'type value does not include in values' }.to_json) end it 'validates against values in a proc' do ValidationsSpec::ValuesModel.add_value('valid-type4') get('/custom_message/lambda', type: 'valid-type4') expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 'valid-type4' }.to_json) end it 'does not allow an invalid value for a parameter using lambda' do get('/custom_message/lambda', type: 'invalid-type') expect(last_response.status).to eq 400 expect(last_response.body).to eq({ error: 'type value does not include in values' }.to_json) end end it 'allows a valid value for a parameter' do get('/', type: 'valid-type1') expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 'valid-type1' }.to_json) end it 'does not allow an invalid value for a parameter' do get('/', type: 'invalid-type') expect(last_response.status).to eq 400 expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json) end context 'nil value for a parameter' do it 'does not allow for root params scope' do get('/', type: nil) expect(last_response.status).to eq 400 expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json) end it 'allows for a required param in child scope' do get('/optional_with_required_values') expect(last_response.status).to eq 200 end end it 'allows a valid default value' do get('/default/valid') expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 'valid-type2' }.to_json) end it 'allows a proc for values' do get('/lambda', type: 'valid-type1') expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 'valid-type1' }.to_json) end it 'does not validate updated values without proc' do ValidationsSpec::ValuesModel.add_value('valid-type4') get('/', type: 'valid-type4') expect(last_response.status).to eq 400 expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json) end it 'validates against values in a proc' do ValidationsSpec::ValuesModel.add_value('valid-type4') get('/lambda', type: 'valid-type4') expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 'valid-type4' }.to_json) end it 'does not allow an invalid value for a parameter using lambda' do get('/lambda', type: 'invalid-type') expect(last_response.status).to eq 400 expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json) end it 'validates default value from proc' do get('/default_lambda') expect(last_response.status).to eq 200 end it 'validates default value from proc against values in a proc' do get('/default_and_values_lambda') expect(last_response.status).to eq 200 end it 'raises IncompatibleOptionValues on an invalid default value from proc' do subject = Class.new(Grape::API) expect do subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: ValidationsSpec::ValuesModel.values.sample + '_invalid' } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end it 'raises IncompatibleOptionValues on an invalid default value' do subject = Class.new(Grape::API) expect do subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'invalid-type' } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end it 'raises IncompatibleOptionValues when type is incompatible with values array' do subject = Class.new(Grape::API) expect do subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], type: Symbol } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end it 'allows values to be true or false when setting the type to boolean' do get('/values/optional_boolean', type: true) expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: true }.to_json) end it 'allows values to be a kind of the coerced type not just an instance of it' do get('/values/coercion', type: 10) expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: 10 }.to_json) end it 'allows values to be a kind of the coerced type in an array' do get('/values/array_coercion', type: [10]) expect(last_response.status).to eq 200 expect(last_response.body).to eq({ type: [10] }.to_json) end it 'raises IncompatibleOptionValues when values contains a value that is not a kind of the type' do subject = Class.new(Grape::API) expect do subject.params { requires :type, values: [10.5, 11], type: Integer } end.to raise_error Grape::Exceptions::IncompatibleOptionValues end context 'with a lambda values' do subject do Class.new(Grape::API) do params do optional :type, type: String, values: -> { [SecureRandom.uuid] }, default: -> { SecureRandom.uuid } end get '/random_values' end end def app subject end before do expect(SecureRandom).to receive(:uuid).and_return('foo').once end it 'only evaluates values dynamically with each request' do get '/random_values', type: 'foo' expect(last_response.status).to eq 200 end it 'chooses default' do get '/random_values' expect(last_response.status).to eq 200 end end context 'with a range of values' do subject(:app) do Class.new(Grape::API) do params do optional :value, type: Float, values: 0.0..10.0 end get '/value' do { value: params[:value] }.to_json end params do optional :values, type: Array[Float], values: 0.0..10.0 end get '/values' do { values: params[:values] }.to_json end end end it 'allows a single value inside of the range' do get('/value', value: 5.2) expect(last_response.status).to eq 200 expect(last_response.body).to eq({ value: 5.2 }.to_json) end it 'allows an array of values inside of the range' do get('/values', values: [8.6, 7.5, 3, 0.9]) expect(last_response.status).to eq 200 expect(last_response.body).to eq({ values: [8.6, 7.5, 3.0, 0.9] }.to_json) end it 'rejects a single value outside the range' do get('/value', value: 'a') expect(last_response.status).to eq 400 expect(last_response.body).to eq('value is invalid, value does not have a valid value') end it 'rejects an array of values if any of them are outside the range' do get('/values', values: [8.6, 75, 3, 0.9]) expect(last_response.status).to eq 400 expect(last_response.body).to eq('values does not have a valid value') end end end grape-0.16.2/spec/grape/validations/validators/allow_blank_spec.rb0000644000004100000410000004256712706307017025310 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::AllowBlankValidator do module ValidationsSpec module AllowBlankValidatorSpec class API < Grape::API default_format :json params do requires :name, allow_blank: false end get params do optional :name, allow_blank: false end get '/disallow_blank_optional_param' params do requires :name, allow_blank: true end get '/allow_blank' params do requires :val, type: DateTime, allow_blank: true end get '/allow_datetime_blank' params do requires :val, type: DateTime, allow_blank: false end get '/disallow_datetime_blank' params do requires :val, type: DateTime end get '/default_allow_datetime_blank' params do requires :val, type: Date, allow_blank: true end get '/allow_date_blank' params do requires :val, type: Integer, allow_blank: true end get '/allow_integer_blank' params do requires :val, type: Float, allow_blank: true end get '/allow_float_blank' params do requires :val, type: Fixnum, allow_blank: true end get '/allow_fixnum_blank' params do requires :val, type: Symbol, allow_blank: true end get '/allow_symbol_blank' params do requires :val, type: Boolean, allow_blank: true end get '/allow_boolean_blank' params do requires :val, type: Boolean, allow_blank: false end get '/disallow_boolean_blank' params do optional :user, type: Hash do requires :name, allow_blank: false end end get '/disallow_blank_required_param_in_an_optional_group' params do optional :user, type: Hash do requires :name, type: Date, allow_blank: true end end get '/allow_blank_date_param_in_an_optional_group' params do optional :user, type: Hash do optional :name, allow_blank: false requires :age end end get '/disallow_blank_optional_param_in_an_optional_group' params do requires :user, type: Hash do requires :name, allow_blank: false end end get '/disallow_blank_required_param_in_a_required_group' params do requires :user, type: Hash do requires :name, allow_blank: false end end get '/disallow_string_value_in_a_required_hash_group' params do requires :user, type: Hash do optional :name, allow_blank: false end end get '/disallow_blank_optional_param_in_a_required_group' params do optional :user, type: Hash do optional :name, allow_blank: false end end get '/disallow_string_value_in_an_optional_hash_group' resources :custom_message do params do requires :name, allow_blank: { value: false, message: 'has no value' } end get params do optional :name, allow_blank: { value: false, message: 'has no value' } end get '/disallow_blank_optional_param' params do requires :name, allow_blank: true end get '/allow_blank' params do requires :val, type: DateTime, allow_blank: true end get '/allow_datetime_blank' params do requires :val, type: DateTime, allow_blank: { value: false, message: 'has no value' } end get '/disallow_datetime_blank' params do requires :val, type: DateTime end get '/default_allow_datetime_blank' params do requires :val, type: Date, allow_blank: true end get '/allow_date_blank' params do requires :val, type: Integer, allow_blank: true end get '/allow_integer_blank' params do requires :val, type: Float, allow_blank: true end get '/allow_float_blank' params do requires :val, type: Fixnum, allow_blank: true end get '/allow_fixnum_blank' params do requires :val, type: Symbol, allow_blank: true end get '/allow_symbol_blank' params do requires :val, type: Boolean, allow_blank: true end get '/allow_boolean_blank' params do requires :val, type: Boolean, allow_blank: { value: false, message: 'has no value' } end get '/disallow_boolean_blank' params do optional :user, type: Hash do requires :name, allow_blank: { value: false, message: 'has no value' } end end get '/disallow_blank_required_param_in_an_optional_group' params do optional :user, type: Hash do requires :name, type: Date, allow_blank: true end end get '/allow_blank_date_param_in_an_optional_group' params do optional :user, type: Hash do optional :name, allow_blank: { value: false, message: 'has no value' } requires :age end end get '/disallow_blank_optional_param_in_an_optional_group' params do requires :user, type: Hash do requires :name, allow_blank: { value: false, message: 'has no value' } end end get '/disallow_blank_required_param_in_a_required_group' params do requires :user, type: Hash do requires :name, allow_blank: { value: false, message: 'has no value' } end end get '/disallow_string_value_in_a_required_hash_group' params do requires :user, type: Hash do optional :name, allow_blank: { value: false, message: 'has no value' } end end get '/disallow_blank_optional_param_in_a_required_group' params do optional :user, type: Hash do optional :name, allow_blank: { value: false, message: 'has no value' } end end get '/disallow_string_value_in_an_optional_hash_group' end end end end def app ValidationsSpec::AllowBlankValidatorSpec::API end context 'invalid input' do it 'refuses empty string' do get '/', name: '' expect(last_response.status).to eq(400) get '/disallow_datetime_blank', val: '' expect(last_response.status).to eq(400) end it 'refuses only whitespaces' do get '/', name: ' ' expect(last_response.status).to eq(400) get '/', name: " \n " expect(last_response.status).to eq(400) get '/', name: "\n" expect(last_response.status).to eq(400) end it 'refuses nil' do get '/', name: nil expect(last_response.status).to eq(400) end end context 'custom validation message' do context 'with invalid input' do it 'refuses empty string' do get '/custom_message', name: '' expect(last_response.body).to eq('{"error":"name has no value"}') end it 'refuses empty string for an optional param' do get '/custom_message/disallow_blank_optional_param', name: '' expect(last_response.body).to eq('{"error":"name has no value"}') end it 'refuses only whitespaces' do get '/custom_message', name: ' ' expect(last_response.body).to eq('{"error":"name has no value"}') get '/custom_message', name: " \n " expect(last_response.body).to eq('{"error":"name has no value"}') get '/custom_message', name: "\n" expect(last_response.body).to eq('{"error":"name has no value"}') end it 'refuses nil' do get '/custom_message', name: nil expect(last_response.body).to eq('{"error":"name has no value"}') end end context 'with valid input' do it 'accepts valid input' do get '/custom_message', name: 'bob' expect(last_response.status).to eq(200) end it 'accepts empty input when allow_blank is false' do get '/custom_message/allow_blank', name: '' expect(last_response.status).to eq(200) end it 'accepts empty input' do get '/custom_message/default_allow_datetime_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when datetime allow_blank' do get '/custom_message/allow_datetime_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when date allow_blank' do get '/custom_message/allow_date_blank', val: '' expect(last_response.status).to eq(200) end context 'allow_blank when Numeric' do it 'accepts empty when integer allow_blank' do get '/custom_message/allow_integer_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when float allow_blank' do get '/custom_message/allow_float_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when fixnum allow_blank' do get '/custom_message/allow_fixnum_blank', val: '' expect(last_response.status).to eq(200) end end it 'accepts empty when symbol allow_blank' do get '/custom_message/allow_symbol_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when boolean allow_blank' do get '/custom_message/allow_boolean_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts false when boolean allow_blank' do get '/custom_message/disallow_boolean_blank', val: false expect(last_response.status).to eq(200) end end context 'in an optional group' do context 'as a required param' do it 'accepts a missing group, even with a disallwed blank param' do get '/custom_message/disallow_blank_required_param_in_an_optional_group' expect(last_response.status).to eq(200) end it 'accepts a nested missing date value' do get '/custom_message/allow_blank_date_param_in_an_optional_group', user: { name: '' } expect(last_response.status).to eq(200) end it 'refuses a blank value in an existing group' do get '/custom_message/disallow_blank_required_param_in_an_optional_group', user: { name: '' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user[name] has no value"}') end end context 'as an optional param' do it 'accepts a missing group, even with a disallwed blank param' do get '/custom_message/disallow_blank_optional_param_in_an_optional_group' expect(last_response.status).to eq(200) end it 'accepts a nested missing optional value' do get '/custom_message/disallow_blank_optional_param_in_an_optional_group', user: { age: '29' } expect(last_response.status).to eq(200) end it 'refuses a blank existing value in an existing scope' do get '/custom_message/disallow_blank_optional_param_in_an_optional_group', user: { age: '29', name: '' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user[name] has no value"}') end end end context 'in a required group' do context 'as a required param' do it 'refuses a blank value in a required existing group' do get '/custom_message/disallow_blank_required_param_in_a_required_group', user: { name: '' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user[name] has no value"}') end it 'refuses a string value in a required hash group' do get '/custom_message/disallow_string_value_in_a_required_hash_group', user: '' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user is invalid, user[name] is missing"}') end end context 'as an optional param' do it 'accepts a nested missing value' do get '/custom_message/disallow_blank_optional_param_in_a_required_group', user: { age: '29' } expect(last_response.status).to eq(200) end it 'refuses a blank existing value in an existing scope' do get '/custom_message/disallow_blank_optional_param_in_a_required_group', user: { age: '29', name: '' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user[name] has no value"}') end it 'refuses a string value in an optional hash group' do get '/custom_message/disallow_string_value_in_an_optional_hash_group', user: '' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"user is invalid"}') end end end end context 'valid input' do it 'accepts valid input' do get '/', name: 'bob' expect(last_response.status).to eq(200) end it 'accepts empty input when allow_blank is false' do get '/allow_blank', name: '' expect(last_response.status).to eq(200) end it 'accepts empty input' do get '/default_allow_datetime_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when datetime allow_blank' do get '/allow_datetime_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when date allow_blank' do get '/allow_date_blank', val: '' expect(last_response.status).to eq(200) end context 'allow_blank when Numeric' do it 'accepts empty when integer allow_blank' do get '/allow_integer_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when float allow_blank' do get '/allow_float_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when fixnum allow_blank' do get '/allow_fixnum_blank', val: '' expect(last_response.status).to eq(200) end end it 'accepts empty when symbol allow_blank' do get '/allow_symbol_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts empty when boolean allow_blank' do get '/allow_boolean_blank', val: '' expect(last_response.status).to eq(200) end it 'accepts false when boolean allow_blank' do get '/disallow_boolean_blank', val: false expect(last_response.status).to eq(200) end end context 'in an optional group' do context 'as a required param' do it 'accepts a missing group, even with a disallwed blank param' do get '/disallow_blank_required_param_in_an_optional_group' expect(last_response.status).to eq(200) end it 'accepts a nested missing date value' do get '/allow_blank_date_param_in_an_optional_group', user: { name: '' } expect(last_response.status).to eq(200) end it 'refuses a blank value in an existing group' do get '/disallow_blank_required_param_in_an_optional_group', user: { name: '' } expect(last_response.status).to eq(400) end end context 'as an optional param' do it 'accepts a missing group, even with a disallwed blank param' do get '/disallow_blank_optional_param_in_an_optional_group' expect(last_response.status).to eq(200) end it 'accepts a nested missing optional value' do get '/disallow_blank_optional_param_in_an_optional_group', user: { age: '29' } expect(last_response.status).to eq(200) end it 'refuses a blank existing value in an existing scope' do get '/disallow_blank_optional_param_in_an_optional_group', user: { age: '29', name: '' } expect(last_response.status).to eq(400) end end end context 'in a required group' do context 'as a required param' do it 'refuses a blank value in a required existing group' do get '/disallow_blank_required_param_in_a_required_group', user: { name: '' } expect(last_response.status).to eq(400) end it 'refuses a string value in a required hash group' do get '/disallow_string_value_in_a_required_hash_group', user: '' expect(last_response.status).to eq(400) end end context 'as an optional param' do it 'accepts a nested missing value' do get '/disallow_blank_optional_param_in_a_required_group', user: { age: '29' } expect(last_response.status).to eq(200) end it 'refuses a blank existing value in an existing scope' do get '/disallow_blank_optional_param_in_a_required_group', user: { age: '29', name: '' } expect(last_response.status).to eq(400) end it 'refuses a string value in an optional hash group' do get '/disallow_string_value_in_an_optional_hash_group', user: '' expect(last_response.status).to eq(400) end end end end grape-0.16.2/spec/grape/validations/validators/regexp_spec.rb0000644000004100000410000000364612706307017024310 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::RegexpValidator do module ValidationsSpec module RegexpValidatorSpec class API < Grape::API default_format :json resources :custom_message do params do requires :name, regexp: { value: /^[a-z]+$/, message: 'format is invalid' } end get do end end params do requires :name, regexp: /^[a-z]+$/ end get do end end end end def app ValidationsSpec::RegexpValidatorSpec::API end context 'custom validation message' do context 'with invalid input' do it 'refuses inapppopriate' do get '/custom_message', name: 'invalid name' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"name format is invalid"}') end it 'refuses empty' do get '/custom_message', name: '' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"name format is invalid"}') end end it 'accepts nil' do get '/custom_message', name: nil expect(last_response.status).to eq(200) end it 'accepts valid input' do get '/custom_message', name: 'bob' expect(last_response.status).to eq(200) end end context 'invalid input' do it 'refuses inapppopriate' do get '/', name: 'invalid name' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"name is invalid"}') end it 'refuses empty' do get '/', name: '' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"name is invalid"}') end end it 'accepts nil' do get '/', name: nil expect(last_response.status).to eq(200) end it 'accepts valid input' do get '/', name: 'bob' expect(last_response.status).to eq(200) end end grape-0.16.2/spec/grape/validations/validators/mutual_exclusion_spec.rb0000644000004100000410000000345612706307017026415 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::MutualExclusionValidator do describe '#validate!' do let(:scope) do Struct.new(:opts) do def params(arg) arg end end end let(:mutually_exclusive_params) { [:beer, :wine, :grapefruit] } let(:validator) { described_class.new(mutually_exclusive_params, {}, false, scope.new) } context 'when all mutually exclusive params are present' do let(:params) { { beer: true, wine: true, grapefruit: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end context 'mixed with other params' do let(:mixed_params) { params.merge!(other: true, andanother: true) } it 'still raises a validation exception' do expect do validator.validate! mixed_params end.to raise_error(Grape::Exceptions::Validation) end end end context 'when a subset of mutually exclusive params are present' do let(:params) { { beer: true, grapefruit: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end context 'when params keys come as strings' do let(:params) { { 'beer' => true, 'grapefruit' => true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end context 'when no mutually exclusive params are present' do let(:params) { { beer: true, somethingelse: true } } it 'params' do expect(validator.validate!(params)).to eql params end end end end grape-0.16.2/spec/grape/validations/validators/all_or_none_spec.rb0000644000004100000410000000335612706307017025303 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations::AllOrNoneOfValidator do describe '#validate!' do let(:scope) do Struct.new(:opts) do def params(arg) arg end def required?; end end end let(:all_or_none_params) { [:beer, :wine, :grapefruit] } let(:validator) { described_class.new(all_or_none_params, {}, false, scope.new) } context 'when all restricted params are present' do let(:params) { { beer: true, wine: true, grapefruit: true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end context 'mixed with other params' do let(:mixed_params) { params.merge!(other: true, andanother: true) } it 'does not raise a validation exception' do expect(validator.validate!(mixed_params)).to eql mixed_params end end end context 'when none of the restricted params is selected' do let(:params) { { somethingelse: true } } it 'does not raise a validation exception' do expect(validator.validate!(params)).to eql params end end context 'when only a subset of restricted params are present' do let(:params) { { beer: true, grapefruit: true } } it 'raises a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end context 'mixed with other params' do let(:mixed_params) { params.merge!(other: true, andanother: true) } it 'raise a validation exception' do expect do validator.validate! params end.to raise_error(Grape::Exceptions::Validation) end end end end end grape-0.16.2/spec/grape/dsl/0000755000004100000410000000000012706307016015542 5ustar www-datawww-datagrape-0.16.2/spec/grape/dsl/desc_spec.rb0000644000004100000410000000515512706307016020025 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module DescSpec class Dummy extend Grape::DSL::Desc end end describe Desc do subject { Class.new(DescSpec::Dummy) } describe '.desc' do it 'sets a description' do desc_text = 'The description' options = { message: 'none' } subject.desc desc_text, options expect(subject.namespace_setting(:description)).to eq(options.merge(description: desc_text)) expect(subject.route_setting(:description)).to eq(options.merge(description: desc_text)) end it 'can be set with a block' do expected_options = { description: 'The description', detail: 'more details', params: { first: :param }, entity: Object, http_codes: [[401, 'Unauthorized', 'Entities::Error']], named: 'My named route', headers: [XAuthToken: { description: 'Valdates your identity', required: true }, XOptionalHeader: { description: 'Not really needed', required: false } ] } subject.desc 'The description' do detail 'more details' params(first: :param) success Object failure [[401, 'Unauthorized', 'Entities::Error']] named 'My named route' headers [XAuthToken: { description: 'Valdates your identity', required: true }, XOptionalHeader: { description: 'Not really needed', required: false } ] end expect(subject.namespace_setting(:description)).to eq(expected_options) expect(subject.route_setting(:description)).to eq(expected_options) end it 'can be set with options and a block' do expect(subject).to receive(:warn).with('[DEPRECATION] Passing a options hash and a block to `desc` is deprecated. Move all hash options to block.') desc_text = 'The description' detail_text = 'more details' options = { message: 'none' } subject.desc desc_text, options do detail detail_text end expect(subject.namespace_setting(:description)).to eq(description: desc_text, detail: detail_text) expect(subject.route_setting(:description)).to eq(description: desc_text, detail: detail_text) end end end end end grape-0.16.2/spec/grape/dsl/request_response_spec.rb0000644000004100000410000001725512706307016022521 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module RequestResponseSpec class Dummy include Grape::DSL::RequestResponse def self.set(key, value) settings[key.to_sym] = value end def self.imbue(key, value) settings.imbue(key, value) end end end describe RequestResponse do subject { Class.new(RequestResponseSpec::Dummy) } let(:c_type) { 'application/json' } let(:format) { 'txt' } describe '.default_format' do it 'sets the default format' do expect(subject).to receive(:namespace_inheritable).with(:default_format, :format) subject.default_format :format end it 'returns the format without paramter' do subject.default_format :format expect(subject.default_format).to eq :format end end describe '.format' do it 'sets a new format' do expect(subject).to receive(:namespace_inheritable).with(:format, format.to_sym) expect(subject).to receive(:namespace_inheritable).with(:default_error_formatter, Grape::ErrorFormatter::Txt) subject.format format end end describe '.formatter' do it 'sets the formatter for a content type' do expect(subject).to receive(:namespace_stackable).with(:formatters, c_type.to_sym => :formatter) subject.formatter c_type, :formatter end end describe '.parser' do it 'sets a parser for a content type' do expect(subject).to receive(:namespace_stackable).with(:parsers, c_type.to_sym => :parser) subject.parser c_type, :parser end end describe '.default_error_formatter' do it 'sets a new error formatter' do expect(subject).to receive(:namespace_inheritable).with(:default_error_formatter, Grape::ErrorFormatter::Json) subject.default_error_formatter :json end end describe '.error_formatter' do it 'sets a error_formatter' do format = 'txt' expect(subject).to receive(:namespace_stackable).with(:error_formatters, format.to_sym => :error_formatter) subject.error_formatter format, :error_formatter end it 'understands syntactic sugar' do expect(subject).to receive(:namespace_stackable).with(:error_formatters, format.to_sym => :error_formatter) subject.error_formatter format, with: :error_formatter end end describe '.content_type' do it 'sets a content type for a format' do expect(subject).to receive(:namespace_stackable).with(:content_types, format.to_sym => c_type) subject.content_type format, c_type end end describe '.content_types' do it 'returns all content types' do expect(subject.content_types).to eq(xml: 'application/xml', serializable_hash: 'application/json', json: 'application/json', txt: 'text/plain', binary: 'application/octet-stream') end end describe '.default_error_status' do it 'sets a default error status' do expect(subject).to receive(:namespace_inheritable).with(:default_error_status, 500) subject.default_error_status 500 end end describe '.rescue_from' do describe ':all' do it 'sets rescue all to true' do expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true) expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, nil) subject.rescue_from :all end it 'sets given proc as rescue handler' do rescue_handler_proc = proc {} expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true) expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, rescue_handler_proc) subject.rescue_from :all, rescue_handler_proc end it 'sets given block as rescue handler' do rescue_handler_proc = proc {} expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true) expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, rescue_handler_proc) subject.rescue_from :all, &rescue_handler_proc end it 'sets a rescue handler declared through :with option' do with_block = -> { 'hello' } expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true) expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, an_instance_of(Proc)) subject.rescue_from :all, with: with_block end it 'abort if :with option value is not Symbol, String or Proc' do expect { subject.rescue_from :all, with: 1234 }.to raise_error(ArgumentError, 'with: Fixnum, expected Symbol, String or Proc') end it 'abort if both :with option and block are passed' do expect do subject.rescue_from :all, with: -> { 'hello' } do error!('bye') end end.to raise_error(ArgumentError, 'both :with option and block cannot be passed') end end describe 'list of exceptions is passed' do it 'sets hash of exceptions as rescue handlers' do expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => nil) expect(subject).to receive(:namespace_stackable).with(:rescue_options, {}) subject.rescue_from StandardError end it 'rescues only base handlers if rescue_subclasses: false option is passed' do expect(subject).to receive(:namespace_stackable).with(:base_only_rescue_handlers, StandardError => nil) expect(subject).to receive(:namespace_stackable).with(:rescue_options, rescue_subclasses: false) subject.rescue_from StandardError, rescue_subclasses: false end it 'sets given proc as rescue handler for each key in hash' do rescue_handler_proc = proc {} expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => rescue_handler_proc) expect(subject).to receive(:namespace_stackable).with(:rescue_options, {}) subject.rescue_from StandardError, rescue_handler_proc end it 'sets given block as rescue handler for each key in hash' do rescue_handler_proc = proc {} expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => rescue_handler_proc) expect(subject).to receive(:namespace_stackable).with(:rescue_options, {}) subject.rescue_from StandardError, &rescue_handler_proc end it 'sets a rescue handler declared through :with option for each key in hash' do with_block = -> { 'hello' } expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => an_instance_of(Proc)) expect(subject).to receive(:namespace_stackable).with(:rescue_options, with: with_block) subject.rescue_from StandardError, with: with_block end end end describe '.represent' do it 'sets a presenter for a class' do presenter = Class.new expect(subject).to receive(:namespace_stackable).with(:representations, ThisClass: presenter) subject.represent :ThisClass, with: presenter end end end end end grape-0.16.2/spec/grape/dsl/parameters_spec.rb0000644000004100000410000001222712706307016021250 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module ParametersSpec class Dummy include Grape::DSL::Parameters attr_accessor :api, :element, :parent def validate_attributes(*args) @validate_attributes = *args end def validate_attributes_reader @validate_attributes end def push_declared_params(*args) @push_declared_params = args end def push_declared_params_reader @push_declared_params end def validates(*args) @validates = *args end def validates_reader @validates end def extract_message_option(attrs) return nil unless attrs.is_a?(Array) opts = attrs.last.is_a?(Hash) ? attrs.pop : {} (opts.key?(:message) && !opts[:message].nil?) ? opts.delete(:message) : nil end end end describe Parameters do subject { ParametersSpec::Dummy.new } describe '#use' do before do allow_message_expectations_on_nil allow(subject.api).to receive(:namespace_stackable).with(:named_params) end let(:options) { { option: 'value' } } let(:named_params) { { params_group: proc {} } } it 'calls processes associated with named params' do allow(subject.api).to receive(:namespace_stackable_with_hash).and_return(named_params) expect(subject).to receive(:instance_exec).with(options).and_yield subject.use :params_group, options end it 'raises error when non-existent named param is called' do allow(subject.api).to receive(:namespace_stackable_with_hash).and_return({}) expect { subject.use :params_group }.to raise_error('Params :params_group not found!') end end describe '#use_scope' do it 'is alias to #use' do expect(subject.method(:use_scope)).to eq subject.method(:use) end end describe '#includes' do it 'is alias to #use' do expect(subject.method(:includes)).to eq subject.method(:use) end end describe '#requires' do it 'adds a required parameter' do subject.requires :id, type: Integer, desc: 'Identity.' expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.', presence: { value: true, message: nil } }]) expect(subject.push_declared_params_reader).to eq([[:id]]) end end describe '#optional' do it 'adds an optional parameter' do subject.optional :id, type: Integer, desc: 'Identity.' expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.' }]) expect(subject.push_declared_params_reader).to eq([[:id]]) end end describe '#mutually_exclusive' do it 'adds an mutally exclusive parameter validation' do subject.mutually_exclusive :media, :audio expect(subject.validates_reader).to eq([[:media, :audio], { mutual_exclusion: { value: true, message: nil } }]) end end describe '#exactly_one_of' do it 'adds an exactly of one parameter validation' do subject.exactly_one_of :media, :audio expect(subject.validates_reader).to eq([[:media, :audio], { exactly_one_of: { value: true, message: nil } }]) end end describe '#at_least_one_of' do it 'adds an at least one of parameter validation' do subject.at_least_one_of :media, :audio expect(subject.validates_reader).to eq([[:media, :audio], { at_least_one_of: { value: true, message: nil } }]) end end describe '#all_or_none_of' do it 'adds an all or none of parameter validation' do subject.all_or_none_of :media, :audio expect(subject.validates_reader).to eq([[:media, :audio], { all_or_none_of: { value: true, message: nil } }]) end end describe '#group' do it 'is alias to #requires' do expect(subject.method(:group)).to eq subject.method(:requires) end end describe '#params' do it 'inherits params from parent' do parent_params = { foo: 'bar' } subject.parent = Object.new allow(subject.parent).to receive(:params).and_return(parent_params) expect(subject.params({})).to eq parent_params end describe 'when params argument is an array of hashes' do it 'returns values of each hash for @element key' do subject.element = :foo expect(subject.params([{ foo: 'bar' }, { foo: 'baz' }])).to eq(%w(bar baz)) end end describe 'when params argument is a hash' do it 'returns value for @element key' do subject.element = :foo expect(subject.params(foo: 'bar')).to eq('bar') end end describe 'when params argument is not a array or a hash' do it 'returns empty hash' do subject.element = Object.new expect(subject.params(Object.new)).to eq({}) end end end end end end grape-0.16.2/spec/grape/dsl/routing_spec.rb0000644000004100000410000002051612706307016020574 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module RoutingSpec class Dummy include Grape::DSL::Routing end end describe Routing do subject { Class.new(RoutingSpec::Dummy) } let(:proc) { ->() {} } let(:options) { { a: :b } } let(:path) { '/dummy' } describe '.version' do it 'sets a version for route' do version = 'v1' expect(subject).to receive(:namespace_inheritable).with(:version, [version]) expect(subject).to receive(:namespace_inheritable).with(:version_options, using: :path) expect(subject.version(version)).to eq(version) end end describe '.prefix' do it 'sets a prefix for route' do prefix = '/api' expect(subject).to receive(:namespace_inheritable).with(:root_prefix, prefix) subject.prefix prefix end end describe '.scope' do it 'create a scope without affecting the URL' do expect(subject).to receive(:within_namespace) subject.scope {} end end describe '.do_not_route_head!' do it 'sets do not route head option' do expect(subject).to receive(:namespace_inheritable).with(:do_not_route_head, true) subject.do_not_route_head! end end describe '.do_not_route_options!' do it 'sets do not route options option' do expect(subject).to receive(:namespace_inheritable).with(:do_not_route_options, true) subject.do_not_route_options! end end describe '.mount' do it 'mounts on a nested path' do subject = Class.new(Grape::API) app1 = Class.new(Grape::API) app2 = Class.new(Grape::API) app2.get '/nice' do 'play' end subject.mount app1 => '/app1' app1.mount app2 => '/app2' expect(subject.inheritable_setting.to_hash[:namespace]).to eq({}) expect(subject.inheritable_setting.to_hash[:namespace_inheritable]).to eq({}) expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1']) expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1', '/app2']) end end describe '.route' do before do allow(subject).to receive(:endpoints).and_return([]) allow(subject).to receive(:route_end) allow(subject).to receive(:reset_validations!) end it 'marks end of the route' do expect(subject).to receive(:route_end) subject.route(:any) end it 'resets validations' do expect(subject).to receive(:reset_validations!) subject.route(:any) end it 'defines a new endpoint' do expect { subject.route(:any) } .to change { subject.endpoints.count }.from(0).to(1) end it 'does not duplicate identical endpoints' do subject.route(:any) expect { subject.route(:any) } .to_not change(subject.endpoints, :count) end it 'generates correct endpoint options' do allow(subject).to receive(:route_setting).with(:description).and_return(fiz: 'baz') allow(subject).to receive(:namespace_stackable_with_hash).and_return(nuz: 'naz') expect(Grape::Endpoint).to receive(:new) do |_inheritable_setting, endpoint_options| expect(endpoint_options[:method]).to eq :get expect(endpoint_options[:path]).to eq '/foo' expect(endpoint_options[:for]).to eq subject expect(endpoint_options[:route_options]).to eq(foo: 'bar', fiz: 'baz', params: { nuz: 'naz' }) end.and_yield subject.route(:get, '/foo', { foo: 'bar' }, &proc {}) end end describe '.get' do it 'delegates to .route' do expect(subject).to receive(:route).with('GET', path, options) subject.get path, options, &proc end end describe '.post' do it 'delegates to .route' do expect(subject).to receive(:route).with('POST', path, options) subject.post path, options, &proc end end describe '.put' do it 'delegates to .route' do expect(subject).to receive(:route).with('PUT', path, options) subject.put path, options, &proc end end describe '.head' do it 'delegates to .route' do expect(subject).to receive(:route).with('HEAD', path, options) subject.head path, options, &proc end end describe '.delete' do it 'delegates to .route' do expect(subject).to receive(:route).with('DELETE', path, options) subject.delete path, options, &proc end end describe '.options' do it 'delegates to .route' do expect(subject).to receive(:route).with('OPTIONS', path, options) subject.options path, options, &proc end end describe '.patch' do it 'delegates to .route' do expect(subject).to receive(:route).with('PATCH', path, options) subject.patch path, options, &proc end end describe '.namespace' do let(:new_namespace) { Object.new } it 'creates a new namespace with given name and options' do expect(subject).to receive(:within_namespace).and_yield expect(subject).to receive(:nest).and_yield expect(Namespace).to receive(:new).with(:foo, foo: 'bar').and_return(new_namespace) expect(subject).to receive(:namespace_stackable).with(:namespace, new_namespace) subject.namespace :foo, foo: 'bar', &proc {} end it 'calls #joined_space_path on Namespace' do result_of_namspace_stackable = Object.new allow(subject).to receive(:namespace_stackable).and_return(result_of_namspace_stackable) expect(Namespace).to receive(:joined_space_path).with(result_of_namspace_stackable) subject.namespace end end describe '.group' do it 'is alias to #namespace' do expect(subject.method(:group)).to eq subject.method(:namespace) end end describe '.resource' do it 'is alias to #namespace' do expect(subject.method(:resource)).to eq subject.method(:namespace) end end describe '.resources' do it 'is alias to #namespace' do expect(subject.method(:resources)).to eq subject.method(:namespace) end end describe '.segment' do it 'is alias to #namespace' do expect(subject.method(:segment)).to eq subject.method(:namespace) end end describe '.routes' do let(:routes) { Object.new } it 'returns value received from #prepare_routes' do expect(subject).to receive(:prepare_routes).and_return(routes) expect(subject.routes).to eq routes end context 'when #routes was already called once' do before do allow(subject).to receive(:prepare_routes).and_return(routes) subject.routes end it 'it does not call prepare_routes again' do expect(subject).to_not receive(:prepare_routes) expect(subject.routes).to eq routes end end end describe '.route_param' do it 'calls #namespace with given params' do expect(subject).to receive(:namespace).with(':foo', {}).and_yield subject.route_param('foo', {}, &proc {}) end let(:regex) { /(.*)/ } let!(:options) { { requirements: regex } } it 'nests requirements option under param name' do expect(subject).to receive(:namespace) do |_param, options| expect(options[:requirements][:foo]).to eq regex end subject.route_param('foo', options, &proc {}) end it 'does not modify options parameter' do allow(subject).to receive(:namespace) expect { subject.route_param('foo', options, &proc {}) } .to_not change { options } end end describe '.versions' do it 'returns last defined version' do subject.version 'v1' subject.version 'v2' expect(subject.version).to eq('v2') end end end end end grape-0.16.2/spec/grape/dsl/configuration_spec.rb0000644000004100000410000000040212706307016021744 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module ConfigurationSpec class Dummy include Grape::DSL::Configuration end end describe Configuration do subject { Class.new(ConfigurationSpec::Dummy) } end end end grape-0.16.2/spec/grape/dsl/logger_spec.rb0000644000004100000410000000101612706307016020356 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module LoggerSpec class Dummy extend Grape::DSL::Logger end end describe Logger do subject { Class.new(LoggerSpec::Dummy) } let(:logger) { double(:logger) } describe '.logger' do it 'sets a logger' do subject.logger logger expect(subject.logger).to eq logger end it 'returns a logger' do expect(subject.logger logger).to eq logger end end end end end grape-0.16.2/spec/grape/dsl/helpers_spec.rb0000644000004100000410000000316012706307016020543 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module HelpersSpec class Dummy include Grape::DSL::Helpers def self.mod namespace_stackable(:helpers).first end end end module BooleanParam extend Grape::API::Helpers params :requires_toggle_prm do requires :toggle_prm, type: Boolean end end describe Helpers do subject { Class.new(HelpersSpec::Dummy) } let(:proc) do lambda do |*| def test :test end end end describe '.helpers' do it 'adds a module with the given block' do expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original subject.helpers(&proc) expect(subject.mod.instance_methods).to include(:test) end it 'uses provided modules' do mod = Module.new expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original subject.helpers(mod, &proc) expect(subject.mod).to eq mod end context 'with an external file' do it 'sets Boolean as a Virtus::Attribute::Boolean' do subject.helpers BooleanParam expect(subject.mod::Boolean).to eq Virtus::Attribute::Boolean end end end end end end grape-0.16.2/spec/grape/dsl/validations_spec.rb0000644000004100000410000000375012706307016021423 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module ValidationsSpec class Dummy include Grape::DSL::Validations end end describe Validations do subject { ValidationsSpec::Dummy } describe '.reset_validations!' do before do subject.namespace_stackable :declared_params, ['dummy'] subject.namespace_stackable :validations, ['dummy'] subject.namespace_stackable :params, ['dummy'] subject.route_setting :description, description: 'lol', params: ['dummy'] subject.reset_validations! end after do subject.unset_route_setting :description end it 'resets declared params' do expect(subject.namespace_stackable(:declared_params)).to eq [] end it 'resets validations' do expect(subject.namespace_stackable(:validations)).to eq [] end it 'resets params' do expect(subject.namespace_stackable(:params)).to eq [] end it 'resets documentation params' do expect(subject.route_setting(:description)[:params]).to be_nil end it 'does not reset documentation description' do expect(subject.route_setting(:description)[:description]).to eq 'lol' end end describe '.params' do it 'returns a ParamsScope' do expect(subject.params).to be_a Grape::Validations::ParamsScope end it 'evaluates block' do expect { subject.params { fail 'foo' } }.to raise_error RuntimeError, 'foo' end end describe '.document_attribute' do before do subject.document_attribute([full_name: 'xxx'], foo: 'bar') end it 'creates a param documentation' do expect(subject.namespace_stackable(:params)).to eq(['xxx' => { foo: 'bar' }]) expect(subject.route_setting(:description)).to eq(params: { 'xxx' => { foo: 'bar' } }) end end end end end grape-0.16.2/spec/grape/dsl/inside_route_spec.rb0000644000004100000410000002135312706307016021576 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module InsideRouteSpec class Dummy include Grape::DSL::InsideRoute attr_reader :env, :request, :new_settings def initialize @env = {} @header = {} @new_settings = { namespace_inheritable: {}, namespace_stackable: {} } end end end end end describe Grape::Endpoint do subject { Grape::DSL::InsideRouteSpec::Dummy.new } describe '#version' do it 'defaults to nil' do expect(subject.version).to be nil end it 'returns env[api.version]' do subject.env['api.version'] = 'dummy' expect(subject.version).to eq 'dummy' end end describe '#error!' do it 'throws :error' do expect { subject.error! 'Not Found', 404 }.to throw_symbol(:error) end describe 'thrown' do before do catch(:error) { subject.error! 'Not Found', 404 } end it 'sets status' do expect(subject.status).to eq 404 end end describe 'default_error_status' do before do subject.namespace_inheritable(:default_error_status, 500) catch(:error) { subject.error! 'Unknown' } end it 'sets status to default_error_status' do expect(subject.status).to eq 500 end end # self.status(status || settings[:default_error_status]) # throw :error, message: message, status: self.status, headers: headers end describe '#redirect' do describe 'default' do before do subject.redirect '/' end it 'sets status to 302' do expect(subject.status).to eq 302 end it 'sets location header' do expect(subject.header['Location']).to eq '/' end end describe 'permanent' do before do subject.redirect '/', permanent: true end it 'sets status to 301' do expect(subject.status).to eq 301 end it 'sets location header' do expect(subject.header['Location']).to eq '/' end end end describe '#status' do %w(GET PUT DELETE OPTIONS).each do |method| it 'defaults to 200 on GET' do request = Grape::Request.new(Rack::MockRequest.env_for('/', method: method)) expect(subject).to receive(:request).and_return(request) expect(subject.status).to eq 200 end end it 'defaults to 201 on POST' do request = Grape::Request.new(Rack::MockRequest.env_for('/', method: 'POST')) expect(subject).to receive(:request).and_return(request) expect(subject.status).to eq 201 end it 'returns status set' do subject.status 501 expect(subject.status).to eq 501 end it 'accepts symbol for status' do subject.status :see_other expect(subject.status).to eq 303 end it 'raises error if unknow symbol is passed' do expect { subject.status :foo_bar } .to raise_error(ArgumentError, 'Status code :foo_bar is invalid.') end it 'accepts unknown Fixnum status codes' do expect { subject.status 210 }.to_not raise_error end it 'raises error if status is not a fixnum or symbol' do expect { subject.status Object.new } .to raise_error(ArgumentError, 'Status code must be Fixnum or Symbol.') end end describe '#content_type' do describe 'set' do before do subject.content_type 'text/plain' end it 'returns value' do expect(subject.content_type).to eq 'text/plain' end end it 'returns default' do expect(subject.content_type).to be nil end end describe '#cookies' do it 'returns an instance of Cookies' do expect(subject.cookies).to be_a Grape::Cookies end end describe '#body' do describe 'set' do before do subject.body 'body' end it 'returns value' do expect(subject.body).to eq 'body' end end describe 'false' do before do subject.body false end it 'sets status to 204' do expect(subject.body).to eq '' expect(subject.status).to eq 204 end end it 'returns default' do expect(subject.body).to be nil end end describe '#file' do describe 'set' do context 'as file path' do let(:file_path) { '/some/file/path' } let(:file_response) do file_body = Grape::ServeFile::FileBody.new(file_path) Grape::ServeFile::FileResponse.new(file_body) end before do subject.file file_path end it 'returns value wrapped in FileResponse' do expect(subject.file).to eq file_response end end context 'as object (backward compatibility)' do let(:file_object) { Class.new } let(:file_response) do Grape::ServeFile::FileResponse.new(file_object) end before do subject.file file_object end it 'returns value wrapped in FileResponse' do expect(subject.file).to eq file_response end end end it 'returns default' do expect(subject.file).to be nil end end describe '#stream' do describe 'set' do let(:file_object) { Class.new } before do subject.header 'Cache-Control', 'cache' subject.header 'Content-Length', 123 subject.header 'Transfer-Encoding', 'base64' subject.stream file_object end it 'returns value wrapped in FileResponse' do expect(subject.stream).to eq Grape::ServeFile::FileResponse.new(file_object) end it 'also sets result of file to value wrapped in FileResponse' do expect(subject.file).to eq Grape::ServeFile::FileResponse.new(file_object) end it 'sets Cache-Control header to no-cache' do expect(subject.header['Cache-Control']).to eq 'no-cache' end it 'sets Content-Length header to nil' do expect(subject.header['Content-Length']).to eq nil end it 'sets Transfer-Encoding header to nil' do expect(subject.header['Transfer-Encoding']).to eq nil end end it 'returns default' do expect(subject.file).to be nil end end describe '#route' do before do subject.env['grape.routing_args'] = {} subject.env['grape.routing_args'][:route_info] = 'dummy' end it 'returns route_info' do expect(subject.route).to eq 'dummy' end end describe '#present' do # see entity_spec.rb for entity representation spec coverage describe 'dummy' do before do subject.present 'dummy' end it 'presents dummy object' do expect(subject.body).to eq 'dummy' end end describe 'with' do describe 'entity' do let(:entity_mock) do entity_mock = Object.new allow(entity_mock).to receive(:represent).and_return('dummy') entity_mock end describe 'instance' do before do subject.present 'dummy', with: entity_mock end it 'presents dummy object' do expect(subject.body).to eq 'dummy' end end end end describe 'multiple entities' do let(:entity_mock1) do entity_mock1 = Object.new allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1') entity_mock1 end let(:entity_mock2) do entity_mock2 = Object.new allow(entity_mock2).to receive(:represent).and_return(dummy2: 'dummy2') entity_mock2 end describe 'instance' do before do subject.present 'dummy1', with: entity_mock1 subject.present 'dummy2', with: entity_mock2 end it 'presents both dummy objects' do expect(subject.body[:dummy1]).to eq 'dummy1' expect(subject.body[:dummy2]).to eq 'dummy2' end end end describe 'non mergeable entity' do let(:entity_mock1) do entity_mock1 = Object.new allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1') entity_mock1 end let(:entity_mock2) do entity_mock2 = Object.new allow(entity_mock2).to receive(:represent).and_return('not a hash') entity_mock2 end describe 'instance' do it 'fails' do subject.present 'dummy1', with: entity_mock1 expect do subject.present 'dummy2', with: entity_mock2 end.to raise_error ArgumentError, 'Representation of type String cannot be merged.' end end end end describe '#declared' do # see endpoint_spec.rb#declared for spec coverage it 'is not available by default' do expect { subject.declared({}) }.to raise_error( Grape::DSL::InsideRoute::MethodNotYetAvailable) end end end grape-0.16.2/spec/grape/dsl/middleware_spec.rb0000644000004100000410000000135012706307016021215 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module MiddlewareSpec class Dummy include Grape::DSL::Middleware end end describe Middleware do subject { Class.new(MiddlewareSpec::Dummy) } let(:proc) { ->() {} } describe '.use' do it 'adds a middleware' do expect(subject).to receive(:namespace_stackable).with(:middleware, [:my_middleware, :arg1, proc]) subject.use :my_middleware, :arg1, &proc end end describe '.middleware' do it 'returns the middleware stack' do subject.use :my_middleware, :arg1, &proc expect(subject.middleware).to eq [[:my_middleware, :arg1, proc]] end end end end end grape-0.16.2/spec/grape/dsl/callbacks_spec.rb0000644000004100000410000000222012706307016021014 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module CallbacksSpec class Dummy include Grape::DSL::Callbacks end end describe Callbacks do subject { Class.new(CallbacksSpec::Dummy) } let(:proc) { ->() {} } describe '.before' do it 'adds a block to "before"' do expect(subject).to receive(:namespace_stackable).with(:befores, proc) subject.before(&proc) end end describe '.before_validation' do it 'adds a block to "before_validation"' do expect(subject).to receive(:namespace_stackable).with(:before_validations, proc) subject.before_validation(&proc) end end describe '.after_validation' do it 'adds a block to "after_validation"' do expect(subject).to receive(:namespace_stackable).with(:after_validations, proc) subject.after_validation(&proc) end end describe '.after' do it 'adds a block to "after"' do expect(subject).to receive(:namespace_stackable).with(:afters, proc) subject.after(&proc) end end end end end grape-0.16.2/spec/grape/dsl/settings_spec.rb0000644000004100000410000002020312706307016020736 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module SettingsSpec class Dummy include Grape::DSL::Settings def reset_validations!; end end end describe Settings do subject { SettingsSpec::Dummy.new } describe '#unset' do it 'deletes a key from settings' do subject.namespace_setting :dummy, 1 expect(subject.inheritable_setting.namespace.keys).to include(:dummy) subject.unset :namespace, :dummy expect(subject.inheritable_setting.namespace.keys).not_to include(:dummy) end end describe '#get_or_set' do it 'sets a values' do subject.get_or_set :namespace, :dummy, 1 expect(subject.namespace_setting(:dummy)).to eq 1 end it 'returns a value when nil is new value is provided' do subject.get_or_set :namespace, :dummy, 1 expect(subject.get_or_set(:namespace, :dummy, nil)).to eq 1 end end describe '#global_setting' do it 'delegates to get_or_set' do expect(subject).to receive(:get_or_set).with(:global, :dummy, 1) subject.global_setting(:dummy, 1) end end describe '#unset_global_setting' do it 'delegates to unset' do expect(subject).to receive(:unset).with(:global, :dummy) subject.unset_global_setting(:dummy) end end describe '#route_setting' do it 'delegates to get_or_set' do expect(subject).to receive(:get_or_set).with(:route, :dummy, 1) subject.route_setting(:dummy, 1) end it 'sets a value until the next route' do subject.route_setting :some_thing, :foo_bar expect(subject.route_setting(:some_thing)).to eq :foo_bar subject.route_end expect(subject.route_setting(:some_thing)).to be_nil end end describe '#unset_route_setting' do it 'delegates to unset' do expect(subject).to receive(:unset).with(:route, :dummy) subject.unset_route_setting(:dummy) end end describe '#namespace_setting' do it 'delegates to get_or_set' do expect(subject).to receive(:get_or_set).with(:namespace, :dummy, 1) subject.namespace_setting(:dummy, 1) end it 'sets a value until the end of a namespace' do subject.namespace_start subject.namespace_setting :some_thing, :foo_bar expect(subject.namespace_setting(:some_thing)).to eq :foo_bar subject.namespace_end expect(subject.namespace_setting(:some_thing)).to be_nil end it 'resets values after leaving nested namespaces' do subject.namespace_start subject.namespace_setting :some_thing, :foo_bar expect(subject.namespace_setting(:some_thing)).to eq :foo_bar subject.namespace_start expect(subject.namespace_setting(:some_thing)).to be_nil subject.namespace_end expect(subject.namespace_setting(:some_thing)).to eq :foo_bar subject.namespace_end expect(subject.namespace_setting(:some_thing)).to be_nil end end describe '#unset_namespace_setting' do it 'delegates to unset' do expect(subject).to receive(:unset).with(:namespace, :dummy) subject.unset_namespace_setting(:dummy) end end describe '#namespace_inheritable' do it 'delegates to get_or_set' do expect(subject).to receive(:get_or_set).with(:namespace_inheritable, :dummy, 1) subject.namespace_inheritable(:dummy, 1) end it 'inherits values from surrounding namespace' do subject.namespace_start subject.namespace_inheritable(:some_thing, :foo_bar) expect(subject.namespace_inheritable(:some_thing)).to eq :foo_bar subject.namespace_start expect(subject.namespace_inheritable(:some_thing)).to eq :foo_bar subject.namespace_inheritable(:some_thing, :foo_bar_2) expect(subject.namespace_inheritable(:some_thing)).to eq :foo_bar_2 subject.namespace_end expect(subject.namespace_inheritable(:some_thing)).to eq :foo_bar subject.namespace_end end end describe '#unset_namespace_inheritable' do it 'delegates to unset' do expect(subject).to receive(:unset).with(:namespace_inheritable, :dummy) subject.unset_namespace_inheritable(:dummy) end end describe '#namespace_stackable' do it 'delegates to get_or_set' do expect(subject).to receive(:get_or_set).with(:namespace_stackable, :dummy, 1) subject.namespace_stackable(:dummy, 1) end it 'stacks values from surrounding namespace' do subject.namespace_start subject.namespace_stackable(:some_thing, :foo_bar) expect(subject.namespace_stackable(:some_thing)).to eq [:foo_bar] subject.namespace_start expect(subject.namespace_stackable(:some_thing)).to eq [:foo_bar] subject.namespace_stackable(:some_thing, :foo_bar_2) expect(subject.namespace_stackable(:some_thing)).to eq [:foo_bar, :foo_bar_2] subject.namespace_end expect(subject.namespace_stackable(:some_thing)).to eq [:foo_bar] subject.namespace_end end end describe '#unset_namespace_stackable' do it 'delegates to unset' do expect(subject).to receive(:unset).with(:namespace_stackable, :dummy) subject.unset_namespace_stackable(:dummy) end end describe '#api_class_setting' do it 'delegates to get_or_set' do expect(subject).to receive(:get_or_set).with(:api_class, :dummy, 1) subject.api_class_setting(:dummy, 1) end end describe '#unset_api_class_setting' do it 'delegates to unset' do expect(subject).to receive(:unset).with(:api_class, :dummy) subject.unset_api_class_setting(:dummy) end end describe '#within_namespace' do it 'calls start and end for a namespace' do expect(subject).to receive :namespace_start expect(subject).to receive :namespace_end subject.within_namespace do end end it 'returns the last result' do result = subject.within_namespace do 1 end expect(result).to eq 1 end end describe 'complex scenario' do it 'plays well' do obj1 = SettingsSpec::Dummy.new obj2 = SettingsSpec::Dummy.new obj3 = SettingsSpec::Dummy.new obj1_copy = nil obj2_copy = nil obj3_copy = nil obj1.within_namespace do obj1.namespace_stackable(:some_thing, :obj1) expect(obj1.namespace_stackable(:some_thing)).to eq [:obj1] obj1_copy = obj1.inheritable_setting.point_in_time_copy end expect(obj1.namespace_stackable(:some_thing)).to eq [] expect(obj1_copy.namespace_stackable[:some_thing]).to eq [:obj1] obj2.within_namespace do obj2.namespace_stackable(:some_thing, :obj2) expect(obj2.namespace_stackable(:some_thing)).to eq [:obj2] obj2_copy = obj2.inheritable_setting.point_in_time_copy end expect(obj2.namespace_stackable(:some_thing)).to eq [] expect(obj2_copy.namespace_stackable[:some_thing]).to eq [:obj2] obj3.within_namespace do obj3.namespace_stackable(:some_thing, :obj3) expect(obj3.namespace_stackable(:some_thing)).to eq [:obj3] obj3_copy = obj3.inheritable_setting.point_in_time_copy end expect(obj3.namespace_stackable(:some_thing)).to eq [] expect(obj3_copy.namespace_stackable[:some_thing]).to eq [:obj3] obj1.top_level_setting.inherit_from obj2_copy.point_in_time_copy obj2.top_level_setting.inherit_from obj3_copy.point_in_time_copy expect(obj1_copy.namespace_stackable[:some_thing]).to eq [:obj3, :obj2, :obj1] end end end end end grape-0.16.2/spec/grape/dsl/headers_spec.rb0000644000004100000410000000125512706307016020517 0ustar www-datawww-datarequire 'spec_helper' module Grape module DSL module HeadersSpec class Dummy include Grape::DSL::Headers end end describe Headers do subject { HeadersSpec::Dummy.new } describe '#header' do describe 'set' do before do subject.header 'Name', 'Value' end it 'returns value' do expect(subject.header['Name']).to eq 'Value' expect(subject.header('Name')).to eq 'Value' end end it 'returns nil' do expect(subject.header['Name']).to be nil expect(subject.header('Name')).to be nil end end end end end grape-0.16.2/spec/grape/integration/0000755000004100000410000000000012706307016017303 5ustar www-datawww-datagrape-0.16.2/spec/grape/integration/global_namespace_function_spec.rb0000644000004100000410000000064312706307016026026 0ustar www-datawww-data# see https://github.com/ruby-grape/grape/issues/1348 require 'spec_helper' def namespace fail end describe Grape::API do subject do Class.new(Grape::API) do format :json get do { ok: true } end end end def app subject end context 'with a global namespace function' do it 'works' do get '/' expect(last_response.status).to eq 200 end end end grape-0.16.2/spec/grape/integration/rack_sendfile_spec.rb0000644000004100000410000000164012706307016023434 0ustar www-datawww-datarequire 'spec_helper' describe Rack::Sendfile do subject do send_file = file_streamer app = Class.new(Grape::API) do use Rack::Sendfile format :json get do file send_file end end options = { method: 'GET', 'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect', 'HTTP_X_ACCEL_MAPPING' => '/accel/mapping/=/replaced/' } env = Rack::MockRequest.env_for('/', options) app.call(env) end context do let(:file_streamer) do double(:file_streamer, to_path: '/accel/mapping/some/path') end it 'contains Sendfile headers' do headers = subject[1] expect(headers).to include('X-Accel-Redirect') end end context do let(:file_streamer) do double(:file_streamer) end it 'not contains Sendfile headers' do headers = subject[1] expect(headers).to_not include('X-Accel-Redirect') end end end grape-0.16.2/spec/grape/integration/rack_spec.rb0000644000004100000410000000170612706307016021566 0ustar www-datawww-datarequire 'spec_helper' describe Rack do it 'correctly populates params from a Tempfile' do input = Tempfile.new 'rubbish' begin app = Class.new(Grape::API) do format :json post do { params_keys: params.keys } end end input.write({ test: '123' * 10_000 }.to_json) input.rewind options = { input: input, method: 'POST', 'CONTENT_TYPE' => 'application/json' } env = Rack::MockRequest.env_for('/', options) unless RUBY_PLATFORM == 'java' major, minor, patch = Rack.release.split('.').map(&:to_i) patch ||= 0 # rack <= 1.5.2 does not specify patch version pending 'Rack 1.5.3 or 1.6.1 required' unless major >= 1 && ((minor == 5 && patch >= 3) || (minor >= 6)) end expect(JSON.parse(app.call(env)[2].body.first)['params_keys']).to match_array('test') ensure input.close input.unlink end end end grape-0.16.2/spec/grape/presenters/0000755000004100000410000000000012706307017017153 5ustar www-datawww-datagrape-0.16.2/spec/grape/presenters/presenter_spec.rb0000644000004100000410000000321112706307017022516 0ustar www-datawww-datarequire 'spec_helper' module Grape module Presenters module PresenterSpec class Dummy include Grape::DSL::InsideRoute attr_reader :env, :request, :new_settings def initialize @env = {} @header = {} @new_settings = { namespace_inheritable: {}, namespace_stackable: {} } end end end describe Presenter do describe 'represent' do let(:object_mock) do Object.new end it 'represent object' do expect(Presenter.represent(object_mock)).to eq object_mock end end subject { PresenterSpec::Dummy.new } describe 'present' do let(:hash_mock) do { key: :value } end describe 'instance' do before do subject.present hash_mock, with: Grape::Presenters::Presenter end it 'presents dummy hash' do expect(subject.body).to eq hash_mock end end describe 'multiple presenter' do let(:hash_mock1) do { key1: :value1 } end let(:hash_mock2) do { key2: :value2 } end describe 'instance' do before do subject.present hash_mock1, with: Grape::Presenters::Presenter subject.present hash_mock2, with: Grape::Presenters::Presenter end it 'presents both dummy presenter' do expect(subject.body[:key1]).to eq hash_mock1[:key1] expect(subject.body[:key2]).to eq hash_mock2[:key2] end end end end end end end grape-0.16.2/spec/grape/validations_spec.rb0000644000004100000410000015070012706307017020640 0ustar www-datawww-datarequire 'spec_helper' describe Grape::Validations do subject { Class.new(Grape::API) } def app subject end describe 'params' do context 'optional' do it 'validates when params is present' do subject.params do optional :a_number, regexp: /^[0-9]+$/ end subject.get '/optional' do 'optional works!' end get '/optional', a_number: 'string' expect(last_response.status).to eq(400) expect(last_response.body).to eq('a_number is invalid') get '/optional', a_number: 45 expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional works!') end it "doesn't validate when param not present" do subject.params do optional :a_number, regexp: /^[0-9]+$/ end subject.get '/optional' do 'optional works!' end get '/optional' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional works!') end it 'adds to declared parameters' do subject.params do optional :some_param end expect(subject.route_setting(:declared_params)).to eq([:some_param]) end end context 'optional using Grape::Entity documentation' do def define_optional_using documentation = { field_a: { type: String }, field_b: { type: String } } subject.params do optional :all, using: documentation end end before do define_optional_using subject.get '/optional' do 'optional with using works' end end it 'adds entity documentation to declared params' do define_optional_using expect(subject.route_setting(:declared_params)).to eq([:field_a, :field_b]) end it 'works when field_a and field_b are not present' do get '/optional' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional with using works') end it 'works when field_a is present' do get '/optional', field_a: 'woof' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional with using works') end it 'works when field_b is present' do get '/optional', field_b: 'woof' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional with using works') end end context 'required' do before do subject.params do requires :key, type: String end subject.get('/required') { 'required works' } subject.put('/required') { { key: params[:key] }.to_json } end it 'errors when param not present' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('key is missing') end it "doesn't throw a missing param when param is present" do get '/required', key: 'cool' expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end it 'adds to declared parameters' do subject.params do requires :some_param end expect(subject.route_setting(:declared_params)).to eq([:some_param]) end it 'works when required field is present but nil' do put '/required', { key: nil }.to_json, 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq('key' => nil) end end context 'requires :all using Grape::Entity documentation' do def define_requires_all documentation = { required_field: { type: String }, optional_field: { type: String } } subject.params do requires :all, except: :optional_field, using: documentation end end before do define_requires_all subject.get '/required' do 'required works' end end it 'adds entity documentation to declared params' do define_requires_all expect(subject.route_setting(:declared_params)).to eq([:required_field, :optional_field]) end it 'errors when required_field is not present' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('required_field is missing') end it 'works when required_field is present' do get '/required', required_field: 'woof' expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end end context 'requires :none using Grape::Entity documentation' do def define_requires_none documentation = { required_field: { type: String }, optional_field: { type: String } } subject.params do requires :none, except: :required_field, using: documentation end end before do define_requires_none subject.get '/required' do 'required works' end end it 'adds entity documentation to declared params' do define_requires_none expect(subject.route_setting(:declared_params)).to eq([:required_field, :optional_field]) end it 'errors when required_field is not present' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('required_field is missing') end it 'works when required_field is present' do get '/required', required_field: 'woof' expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end end context 'requires :all or :none but except a non-existent field using Grape::Entity documentation' do context 'requires :all' do def define_requires_all documentation = { required_field: { type: String }, optional_field: { type: String } } subject.params do requires :all, except: :non_existent_field, using: documentation end end it 'adds only the entity documentation to declared params, nothing more' do define_requires_all expect(subject.route_setting(:declared_params)).to eq([:required_field, :optional_field]) end end context 'requires :none' do def define_requires_none documentation = { required_field: { type: String }, optional_field: { type: String } } subject.params do requires :none, except: :non_existent_field, using: documentation end end it 'adds only the entity documentation to declared params, nothing more' do expect { define_requires_none }.to raise_error(ArgumentError) end end end context 'required with an Array block' do before do subject.params do requires :items, type: Array do requires :key end end subject.get('/required') { 'required works' } subject.put('/required') { { items: params[:items] }.to_json } end it 'errors when param not present' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is missing') end it 'errors when param is not an Array' do get '/required', items: 'hello' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid, items[key] is missing') get '/required', items: { key: 'foo' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid') end it "doesn't throw a missing param when param is present" do get '/required', items: [{ key: 'hello' }, { key: 'world' }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end it "doesn't throw a missing param when param is present but empty" do put '/required', { items: [] }.to_json, 'CONTENT_TYPE' => 'application/json' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq('items' => []) end it 'adds to declared parameters' do subject.params do requires :items, type: Array do requires :key end end expect(subject.route_setting(:declared_params)).to eq([items: [:key]]) end end context 'required with a Hash block' do before do subject.params do requires :items, type: Hash do requires :key end end subject.get '/required' do 'required works' end end it 'errors when param not present' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is missing, items[key] is missing') end it 'errors when param is not a Hash' do get '/required', items: 'hello' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid, items[key] is missing') get '/required', items: [{ key: 'foo' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid') end it "doesn't throw a missing param when param is present" do get '/required', items: { key: 'hello' } expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end it 'adds to declared parameters' do subject.params do requires :items, type: Array do requires :key end end expect(subject.route_setting(:declared_params)).to eq([items: [:key]]) end end context 'hash with a required param with validation' do before do subject.params do requires :items, type: Hash do requires :key, type: String, values: %w(a b) end end subject.get '/required' do 'required works' end end it 'errors when param is not a Hash' do get '/required', items: 'not a hash' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid, items[key] is missing, items[key] is invalid') get '/required', items: [{ key: 'hash in array' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid, items[0][key] does not have a valid value') end it 'works when all params match' do get '/required', items: { key: 'a' } expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end end context 'group' do before do subject.params do group :items, type: Array do requires :key end end subject.get '/required' do 'required works' end end it 'errors when param not present' do get '/required' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is missing') end it "doesn't throw a missing param when param is present" do get '/required', items: [key: 'hello'] expect(last_response.status).to eq(200) expect(last_response.body).to eq('required works') end it 'adds to declared parameters' do subject.params do group :items, type: Array do requires :key end end expect(subject.route_setting(:declared_params)).to eq([items: [:key]]) end end context 'group params with nested params which has a type' do let(:invalid_items) { { items: '' } } before do subject.params do optional :items, type: Array do optional :key1, type: String optional :key2, type: String end end subject.post '/group_with_nested' do 'group with nested works' end end it 'errors when group param is invalid'do post '/group_with_nested', items: invalid_items expect(last_response.status).to eq(400) end end context 'custom validator for a Hash' do module ValuesSpec module DateRangeValidations class DateRangeValidator < Grape::Validations::Base def validate_param!(attr_name, params) return if params[attr_name][:from] <= params[attr_name][:to] fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'" end end end end before do subject.params do optional :date_range, date_range: true, type: Hash do requires :from, type: Integer requires :to, type: Integer end end subject.get('/optional') do 'optional works' end subject.params do requires :date_range, date_range: true, type: Hash do requires :from, type: Integer requires :to, type: Integer end end subject.get('/required') do 'required works' end end context 'which is optional' do it "doesn't throw an error if the validation passes" do get '/optional', date_range: { from: 1, to: 2 } expect(last_response.status).to eq(200) end it 'errors if the validation fails' do get '/optional', date_range: { from: 2, to: 1 } expect(last_response.status).to eq(400) end end context 'which is required' do it "doesn't throw an error if the validation passes" do get '/required', date_range: { from: 1, to: 2 } expect(last_response.status).to eq(200) end it 'errors if the validation fails' do get '/required', date_range: { from: 2, to: 1 } expect(last_response.status).to eq(400) end end end context 'validation within arrays' do before do subject.params do group :children, type: Array do requires :name group :parents, type: Array do requires :name end end end subject.get '/within_array' do 'within array works' end end it 'can handle new scopes within child elements' do get '/within_array', children: [ { name: 'John', parents: [{ name: 'Jane' }, { name: 'Bob' }] }, { name: 'Joe', parents: [{ name: 'Josie' }] } ] expect(last_response.status).to eq(200) expect(last_response.body).to eq('within array works') end it 'errors when a parameter is not present' do get '/within_array', children: [ { name: 'Jim', parents: [{}] }, { name: 'Job', parents: [{ name: 'Joy' }] } ] # NOTE: with body parameters in json or XML or similar this # should actually fail with: children[parents][name] is missing. expect(last_response.status).to eq(400) expect(last_response.body).to eq('children[0][parents] is missing') end it 'safely handles empty arrays and blank parameters' do # NOTE: with body parameters in json or XML or similar this # should actually return 200, since an empty array is valid. get '/within_array', children: [] expect(last_response.status).to eq(400) expect(last_response.body).to eq('children is missing') get '/within_array', children: [name: 'Jay'] expect(last_response.status).to eq(400) expect(last_response.body).to eq('children[0][parents] is missing') end it 'errors when param is not an Array' do # NOTE: would be nicer if these just returned 'children is invalid' get '/within_array', children: 'hello' expect(last_response.status).to eq(400) expect(last_response.body).to eq('children is invalid, children[name] is missing, children[parents] is missing, children[parents] is invalid, children[parents][name] is missing') get '/within_array', children: { name: 'foo' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('children is invalid, children[parents] is missing') get '/within_array', children: [name: 'Jay', parents: { name: 'Fred' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('children[0][parents] is invalid') end end context 'with block param' do before do subject.params do requires :planets, type: Array do requires :name end end subject.get '/req' do 'within array works' end subject.put '/req' do '' end subject.params do group :stars, type: Array do requires :name end end subject.get '/grp' do 'within array works' end subject.put '/grp' do '' end subject.params do requires :name optional :moons, type: Array do requires :name end end subject.get '/opt' do 'within array works' end subject.put '/opt' do '' end end it 'requires defaults to Array type' do get '/req', planets: 'Jupiter, Saturn' expect(last_response.status).to eq(400) expect(last_response.body).to eq('planets is invalid, planets[name] is missing') get '/req', planets: { name: 'Jupiter' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('planets is invalid') get '/req', planets: [{ name: 'Venus' }, { name: 'Mars' }] expect(last_response.status).to eq(200) put_with_json '/req', planets: [] expect(last_response.status).to eq(200) end it 'optional defaults to Array type' do get '/opt', name: 'Jupiter', moons: 'Europa, Ganymede' expect(last_response.status).to eq(400) expect(last_response.body).to eq('moons is invalid, moons[name] is missing') get '/opt', name: 'Jupiter', moons: { name: 'Ganymede' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('moons is invalid') get '/opt', name: 'Jupiter', moons: [{ name: 'Io' }, { name: 'Callisto' }] expect(last_response.status).to eq(200) put_with_json '/opt', name: 'Venus' expect(last_response.status).to eq(200) put_with_json '/opt', name: 'Mercury', moons: [] expect(last_response.status).to eq(200) end it 'group defaults to Array type' do get '/grp', stars: 'Sun' expect(last_response.status).to eq(400) expect(last_response.body).to eq('stars is invalid, stars[name] is missing') get '/grp', stars: { name: 'Sun' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('stars is invalid') get '/grp', stars: [{ name: 'Sun' }] expect(last_response.status).to eq(200) put_with_json '/grp', stars: [] expect(last_response.status).to eq(200) end end context 'validation within arrays with JSON' do before do subject.params do group :children, type: Array do requires :name group :parents, type: Array do requires :name end end end subject.put '/within_array' do 'within array works' end end it 'can handle new scopes within child elements' do put_with_json '/within_array', children: [ { name: 'John', parents: [{ name: 'Jane' }, { name: 'Bob' }] }, { name: 'Joe', parents: [{ name: 'Josie' }] } ] expect(last_response.status).to eq(200) expect(last_response.body).to eq('within array works') end it 'errors when a parameter is not present' do put_with_json '/within_array', children: [ { name: 'Jim', parents: [{}] }, { name: 'Job', parents: [{ name: 'Joy' }] } ] expect(last_response.status).to eq(400) expect(last_response.body).to eq('children[0][parents][0][name] is missing') end it 'safely handles empty arrays and blank parameters' do put_with_json '/within_array', children: [] expect(last_response.status).to eq(200) put_with_json '/within_array', children: [name: 'Jay'] expect(last_response.status).to eq(400) expect(last_response.body).to eq('children[0][parents] is missing') end end context 'optional with an Array block' do before do subject.params do optional :items, type: Array do requires :key end end subject.get '/optional_group' do 'optional group works' end end it "doesn't throw a missing param when the group isn't present" do get '/optional_group' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional group works') end it "doesn't throw a missing param when both group and param are given" do get '/optional_group', items: [{ key: 'foo' }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional group works') end it 'errors when group is present, but required param is not' do get '/optional_group', items: [{ not_key: 'foo' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items[0][key] is missing') end it "errors when param is present but isn't an Array" do get '/optional_group', items: 'hello' expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid, items[key] is missing') get '/optional_group', items: { key: 'foo' } expect(last_response.status).to eq(400) expect(last_response.body).to eq('items is invalid') end it 'adds to declared parameters' do subject.params do optional :items, type: Array do requires :key end end expect(subject.route_setting(:declared_params)).to eq([items: [:key]]) end end context 'nested optional Array blocks' do before do subject.params do optional :items, type: Array do requires :key optional(:optional_subitems, type: Array) { requires :value } requires(:required_subitems, type: Array) { requires :value } end end subject.get('/nested_optional_group') { 'nested optional group works' } end it 'does no internal validations if the outer group is blank' do get '/nested_optional_group' expect(last_response.status).to eq(200) expect(last_response.body).to eq('nested optional group works') end it 'does internal validations if the outer group is present' do get '/nested_optional_group', items: [{ key: 'foo' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items[0][required_subitems] is missing') get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('nested optional group works') end it 'handles deep nesting' do get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }], optional_subitems: [{ not_value: 'baz' }] }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items[0][optional_subitems][0][value] is missing') get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }], optional_subitems: [{ value: 'baz' }] }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('nested optional group works') end it 'handles validation within arrays' do get '/nested_optional_group', items: [{ key: 'foo' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items[0][required_subitems] is missing') get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }] expect(last_response.status).to eq(200) expect(last_response.body).to eq('nested optional group works') get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }], optional_subitems: [{ not_value: 'baz' }] }] expect(last_response.status).to eq(400) expect(last_response.body).to eq('items[0][optional_subitems][0][value] is missing') end it 'adds to declared parameters' do subject.params do optional :items, type: Array do requires :key optional(:optional_subitems, type: Array) { requires :value } requires(:required_subitems, type: Array) { requires :value } end end expect(subject.route_setting(:declared_params)).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]]) end end context 'multiple validation errors' do before do subject.params do requires :yolo requires :swag end subject.get '/two_required' do 'two required works' end end it 'throws the validation errors' do get '/two_required' expect(last_response.status).to eq(400) expect(last_response.body).to match(/yolo is missing/) expect(last_response.body).to match(/swag is missing/) end end context 'custom validation' do module CustomValidations class Customvalidator < Grape::Validations::Base def validate_param!(attr_name, params) return if params[attr_name] == 'im custom' fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: 'is not custom!' end end end context 'when using optional with a custom validator' do before do subject.params do optional :custom, customvalidator: true end subject.get '/optional_custom' do 'optional with custom works!' end end it 'validates when param is present' do get '/optional_custom', custom: 'im custom' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional with custom works!') get '/optional_custom', custom: 'im wrong' expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is not custom!') end it "skips validation when parameter isn't present" do get '/optional_custom' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional with custom works!') end it 'validates with custom validator when param present and incorrect type' do subject.params do optional :custom, type: String, customvalidator: true end get '/optional_custom', custom: 123 expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is not custom!') end end context 'when using requires with a custom validator' do before do subject.params do requires :custom, customvalidator: true end subject.get '/required_custom' do 'required with custom works!' end end it 'validates when param is present' do get '/required_custom', custom: 'im wrong, validate me' expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is not custom!') get '/required_custom', custom: 'im custom' expect(last_response.status).to eq(200) expect(last_response.body).to eq('required with custom works!') end it 'validates when param is not present' do get '/required_custom' expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is missing, custom is not custom!') end context 'nested namespaces' do before do subject.params do requires :custom, customvalidator: true end subject.namespace 'nested' do get 'one' do 'validation failed' end namespace 'nested' do get 'two' do 'validation failed' end end end subject.namespace 'peer' do get 'one' do 'no validation required' end namespace 'nested' do get 'two' do 'no validation required' end end end subject.namespace 'unrelated' do params do requires :name end get 'one' do 'validation required' end namespace 'double' do get 'two' do 'no validation required' end end end end specify 'the parent namespace uses the validator' do get '/nested/one', custom: 'im wrong, validate me' expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is not custom!') end specify 'the nested namespace inherits the custom validator' do get '/nested/nested/two', custom: 'im wrong, validate me' expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is not custom!') end specify 'peer namespaces does not have the validator' do get '/peer/one', custom: 'im not validated' expect(last_response.status).to eq(200) expect(last_response.body).to eq('no validation required') end specify 'namespaces nested in peers should also not have the validator' do get '/peer/nested/two', custom: 'im not validated' expect(last_response.status).to eq(200) expect(last_response.body).to eq('no validation required') end specify 'when nested, specifying a route should clear out the validations for deeper nested params' do get '/unrelated/one' expect(last_response.status).to eq(400) get '/unrelated/double/two' expect(last_response.status).to eq(200) end end end context 'when using options on param' do module CustomValidations class CustomvalidatorWithOptions < Grape::Validations::Base def validate_param!(attr_name, params) return if params[attr_name] == @option[:text] fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message end end end before do subject.params do optional :custom, customvalidator_with_options: { text: 'im custom with options', message: 'is not custom with options!' } end subject.get '/optional_custom' do 'optional with custom works!' end end it 'validates param with custom validator with options' do get '/optional_custom', custom: 'im custom with options' expect(last_response.status).to eq(200) expect(last_response.body).to eq('optional with custom works!') get '/optional_custom', custom: 'im wrong' expect(last_response.status).to eq(400) expect(last_response.body).to eq('custom is not custom with options!') end end end # end custom validation context 'named' do context 'can be defined' do it 'in helpers' do subject.helpers do params :pagination do end end end it 'in helper module which kind of Grape::DSL::Helpers::BaseHelper' do shared_params = Module.new do extend Grape::DSL::Helpers::BaseHelper params :pagination do end end subject.helpers shared_params end end context 'can be included in usual params' do before do shared_params = Module.new do extend Grape::DSL::Helpers::BaseHelper params :period do optional :start_date optional :end_date end end subject.helpers shared_params subject.helpers do params :pagination do optional :page, type: Integer optional :per_page, type: Integer end end end it 'by #use' do subject.params do use :pagination end expect(subject.route_setting(:declared_params)).to eq [:page, :per_page] end it 'by #use with multiple params' do subject.params do use :pagination, :period end expect(subject.route_setting(:declared_params)).to eq [:page, :per_page, :start_date, :end_date] end end context 'with block' do before do subject.helpers do params :order do |options| optional :order, type: Symbol, values: [:asc, :desc], default: options[:default_order] optional :order_by, type: Symbol, values: options[:order_by], default: options[:default_order_by] end end subject.format :json subject.params do use :order, default_order: :asc, order_by: [:name, :created_at], default_order_by: :created_at end subject.get '/order' do { order: params[:order], order_by: params[:order_by] } end end it 'returns defaults' do get '/order' expect(last_response.status).to eq(200) expect(last_response.body).to eq({ order: :asc, order_by: :created_at }.to_json) end it 'overrides default value for order' do get '/order?order=desc' expect(last_response.status).to eq(200) expect(last_response.body).to eq({ order: :desc, order_by: :created_at }.to_json) end it 'overrides default value for order_by' do get '/order?order_by=name' expect(last_response.status).to eq(200) expect(last_response.body).to eq({ order: :asc, order_by: :name }.to_json) end it 'fails with invalid value' do get '/order?order=invalid' expect(last_response.status).to eq(400) expect(last_response.body).to eq('{"error":"order does not have a valid value"}') end end end context 'documentation' do it 'can be included with a hash' do documentation = { example: 'Joe' } subject.params do requires 'first_name', documentation: documentation end subject.get '/' do end expect(subject.routes.first.params['first_name'][:documentation]).to eq(documentation) end end context 'all or none' do context 'optional params' do before :each do subject.resource :custom_message do params do optional :beer optional :wine optional :juice all_or_none_of :beer, :wine, :juice, message: 'all params are required or none is required' end get '/all_or_none' do 'all_or_none works!' end end end context 'with a custom validation message' do it 'errors when any one is present' do get '/custom_message/all_or_none', beer: 'string' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine, juice all params are required or none is required' end it 'works when all params are present' do get '/custom_message/all_or_none', beer: 'string', wine: 'anotherstring', juice: 'anotheranotherstring' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'all_or_none works!' end it 'works when none are present' do get '/custom_message/all_or_none' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'all_or_none works!' end end end end context 'mutually exclusive' do context 'optional params' do context 'with custom validation message' do it 'errors when two or more are present' do subject.resources :custom_message do params do optional :beer optional :wine optional :juice mutually_exclusive :beer, :wine, :juice, message: 'are mutually exclusive cannot pass both params' end get '/mutually_exclusive' do 'mutually_exclusive works!' end end get '/custom_message/mutually_exclusive', beer: 'string', wine: 'anotherstring' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine are mutually exclusive cannot pass both params' end end it 'errors when two or more are present' do subject.params do optional :beer optional :wine optional :juice mutually_exclusive :beer, :wine, :juice end subject.get '/mutually_exclusive' do 'mutually_exclusive works!' end get '/mutually_exclusive', beer: 'string', wine: 'anotherstring' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine are mutually exclusive' end end context 'more than one set of mutually exclusive params' do context 'with a custom validation message' do it 'errors for all sets' do subject.resources :custom_message do params do optional :beer optional :wine mutually_exclusive :beer, :wine, message: 'are mutually exclusive pass only one' optional :nested, type: Hash do optional :scotch optional :aquavit mutually_exclusive :scotch, :aquavit, message: 'are mutually exclusive pass only one' end optional :nested2, type: Array do optional :scotch2 optional :aquavit2 mutually_exclusive :scotch2, :aquavit2, message: 'are mutually exclusive pass only one' end end get '/mutually_exclusive' do 'mutually_exclusive works!' end end get '/custom_message/mutually_exclusive', beer: 'true', wine: 'true', nested: { scotch: 'true', aquavit: 'true' }, nested2: [{ scotch2: 'true' }, { scotch2: 'true', aquavit2: 'true' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine are mutually exclusive pass only one, scotch, aquavit are mutually exclusive pass only one, scotch2, aquavit2 are mutually exclusive pass only one' end end it 'errors for all sets' do subject.params do optional :beer optional :wine mutually_exclusive :beer, :wine optional :nested, type: Hash do optional :scotch optional :aquavit mutually_exclusive :scotch, :aquavit end optional :nested2, type: Array do optional :scotch2 optional :aquavit2 mutually_exclusive :scotch2, :aquavit2 end end subject.get '/mutually_exclusive' do 'mutually_exclusive works!' end get '/mutually_exclusive', beer: 'true', wine: 'true', nested: { scotch: 'true', aquavit: 'true' }, nested2: [{ scotch2: 'true' }, { scotch2: 'true', aquavit2: 'true' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine are mutually exclusive, scotch, aquavit are mutually exclusive, scotch2, aquavit2 are mutually exclusive' end end context 'in a group' do it 'works when only one from the set is present' do subject.params do group :drink, type: Hash do optional :wine optional :beer optional :juice mutually_exclusive :beer, :wine, :juice end end subject.get '/mutually_exclusive_group' do 'mutually_exclusive_group works!' end get '/mutually_exclusive_group', drink: { beer: 'true' } expect(last_response.status).to eq(200) end it 'errors when more than one from the set is present' do subject.params do group :drink, type: Hash do optional :wine optional :beer optional :juice mutually_exclusive :beer, :wine, :juice end end subject.get '/mutually_exclusive_group' do 'mutually_exclusive_group works!' end get '/mutually_exclusive_group', drink: { beer: 'true', juice: 'true', wine: 'true' } expect(last_response.status).to eq(400) end end context 'mutually exclusive params inside Hash group' do it 'invalidates if request param is invalid type' do subject.params do optional :wine, type: Hash do optional :grape optional :country mutually_exclusive :grape, :country end end subject.post '/mutually_exclusive' do 'mutually_exclusive works!' end post '/mutually_exclusive', wine: '2015 sauvignon' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'wine is invalid' end end end context 'exactly one of' do context 'params' do before :each do subject.resources :custom_message do params do optional :beer optional :wine optional :juice exactly_one_of :beer, :wine, :juice, message: { exactly_one: 'are missing, exactly one parameter is required', mutual_exclusion: 'are mutually exclusive, exactly one parameter is required' } end get '/exactly_one_of' do 'exactly_one_of works!' end end subject.params do optional :beer optional :wine optional :juice exactly_one_of :beer, :wine, :juice end subject.get '/exactly_one_of' do 'exactly_one_of works!' end end context 'with a custom validation message' do it 'errors when none are present' do get '/custom_message/exactly_one_of' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter is required' end it 'succeeds when one is present' do get '/custom_message/exactly_one_of', beer: 'string' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'exactly_one_of works!' end it 'errors when two or more are present' do get '/custom_message/exactly_one_of', beer: 'string', wine: 'anotherstring' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine are mutually exclusive, exactly one parameter is required' end end it 'errors when none are present' do get '/exactly_one_of' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter must be provided' end it 'succeeds when one is present' do get '/exactly_one_of', beer: 'string' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'exactly_one_of works!' end it 'errors when two or more are present' do get '/exactly_one_of', beer: 'string', wine: 'anotherstring' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine are mutually exclusive' end end context 'nested params' do before :each do subject.params do requires :nested, type: Hash do optional :beer_nested optional :wine_nested optional :juice_nested exactly_one_of :beer_nested, :wine_nested, :juice_nested end optional :nested2, type: Array do optional :beer_nested2 optional :wine_nested2 optional :juice_nested2 exactly_one_of :beer_nested2, :wine_nested2, :juice_nested2 end end subject.get '/exactly_one_of_nested' do 'exactly_one_of works!' end end it 'errors when none are present' do get '/exactly_one_of_nested' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'nested is missing, beer_nested, wine_nested, juice_nested are missing, exactly one parameter must be provided' end it 'succeeds when one is present' do get '/exactly_one_of_nested', nested: { beer_nested: 'string' } expect(last_response.status).to eq(200) expect(last_response.body).to eq 'exactly_one_of works!' end it 'errors when two or more are present' do get '/exactly_one_of_nested', nested: { beer_nested: 'string' }, nested2: [{ beer_nested2: 'string', wine_nested2: 'anotherstring' }] expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer_nested2, wine_nested2 are mutually exclusive' end end end context 'at least one of' do context 'params' do before :each do subject.resources :custom_message do params do optional :beer optional :wine optional :juice at_least_one_of :beer, :wine, :juice, message: 'are missing, please specify at least one param' end get '/at_least_one_of' do 'at_least_one_of works!' end end subject.params do optional :beer optional :wine optional :juice at_least_one_of :beer, :wine, :juice end subject.get '/at_least_one_of' do 'at_least_one_of works!' end end context 'with a custom validation message' do it 'errors when none are present' do get '/custom_message/at_least_one_of' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine, juice are missing, please specify at least one param' end it 'does not error when one is present' do get '/custom_message/at_least_one_of', beer: 'string' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'at_least_one_of works!' end it 'does not error when two are present' do get '/custom_message/at_least_one_of', beer: 'string', wine: 'string' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'at_least_one_of works!' end end it 'errors when none are present' do get '/at_least_one_of' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'beer, wine, juice are missing, at least one parameter must be provided' end it 'does not error when one is present' do get '/at_least_one_of', beer: 'string' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'at_least_one_of works!' end it 'does not error when two are present' do get '/at_least_one_of', beer: 'string', wine: 'string' expect(last_response.status).to eq(200) expect(last_response.body).to eq 'at_least_one_of works!' end end context 'nested params' do before :each do subject.params do requires :nested, type: Hash do optional :beer_nested optional :wine_nested optional :juice_nested at_least_one_of :beer_nested, :wine_nested, :juice_nested end optional :nested2, type: Array do optional :beer_nested2 optional :wine_nested2 optional :juice_nested2 at_least_one_of :beer_nested2, :wine_nested2, :juice_nested2 end end subject.get '/at_least_one_of_nested' do 'at_least_one_of works!' end end it 'errors when none are present' do get '/at_least_one_of_nested' expect(last_response.status).to eq(400) expect(last_response.body).to eq 'nested is missing, beer_nested, wine_nested, juice_nested are missing, at least one parameter must be provided' end it 'does not error when one is present' do get '/at_least_one_of_nested', nested: { beer_nested: 'string' }, nested2: [{ beer_nested2: 'string' }] expect(last_response.status).to eq(200) expect(last_response.body).to eq 'at_least_one_of works!' end it 'does not error when two are present' do get '/at_least_one_of_nested', nested: { beer_nested: 'string', wine_nested: 'string' }, nested2: [{ beer_nested2: 'string', wine_nested2: 'string' }] expect(last_response.status).to eq(200) expect(last_response.body).to eq 'at_least_one_of works!' end end end context 'in a group' do it 'works when only one from the set is present' do subject.params do group :drink, type: Hash do optional :wine optional :beer optional :juice exactly_one_of :beer, :wine, :juice end end subject.get '/exactly_one_of_group' do 'exactly_one_of_group works!' end get '/exactly_one_of_group', drink: { beer: 'true' } expect(last_response.status).to eq(200) end it 'errors when no parameter from the set is present' do subject.params do group :drink, type: Hash do optional :wine optional :beer optional :juice exactly_one_of :beer, :wine, :juice end end subject.get '/exactly_one_of_group' do 'exactly_one_of_group works!' end get '/exactly_one_of_group', drink: {} expect(last_response.status).to eq(400) end it 'errors when more than one from the set is present' do subject.params do group :drink, type: Hash do optional :wine optional :beer optional :juice exactly_one_of :beer, :wine, :juice end end subject.get '/exactly_one_of_group' do 'exactly_one_of_group works!' end get '/exactly_one_of_group', drink: { beer: 'true', juice: 'true', wine: 'true' } expect(last_response.status).to eq(400) end it 'does not falsely think the param is there if it is provided outside the block' do subject.params do group :drink, type: Hash do optional :wine optional :beer optional :juice exactly_one_of :beer, :wine, :juice end end subject.get '/exactly_one_of_group' do 'exactly_one_of_group works!' end get '/exactly_one_of_group', drink: { foo: 'bar' }, beer: 'true' expect(last_response.status).to eq(400) end end end end grape-0.16.2/spec/grape/util/0000755000004100000410000000000012706307017015736 5ustar www-datawww-datagrape-0.16.2/spec/grape/util/inheritable_values_spec.rb0000644000004100000410000000426412706307017023150 0ustar www-datawww-datarequire 'spec_helper' module Grape module Util describe InheritableValues do let(:parent) { InheritableValues.new } subject { InheritableValues.new(parent) } describe '#delete' do it 'deletes a key' do subject[:some_thing] = :new_foo_bar subject.delete :some_thing expect(subject[:some_thing]).to be_nil end it 'does not delete parent values' do parent[:some_thing] = :foo subject[:some_thing] = :new_foo_bar subject.delete :some_thing expect(subject[:some_thing]).to eq :foo end end describe '#[]' do it 'returns a value' do subject[:some_thing] = :foo expect(subject[:some_thing]).to eq :foo end it 'returns parent value when no value is set' do parent[:some_thing] = :foo expect(subject[:some_thing]).to eq :foo end it 'overwrites parent value with the current one' do parent[:some_thing] = :foo subject[:some_thing] = :foo_bar expect(subject[:some_thing]).to eq :foo_bar end it 'parent values are not changed' do parent[:some_thing] = :foo subject[:some_thing] = :foo_bar expect(parent[:some_thing]).to eq :foo end end describe '#[]=' do it 'sets a value' do subject[:some_thing] = :foo expect(subject[:some_thing]).to eq :foo end end describe '#to_hash' do it 'returns a Hash representation' do parent[:some_thing] = :foo subject[:some_thing_more] = :foo_bar expect(subject.to_hash).to eq(some_thing: :foo, some_thing_more: :foo_bar) end end describe '#clone' do let(:obj_cloned) { subject.clone } context 'complex (i.e. not primitive) data types (ex. entity classes, please see bug #891)' do let(:description) { { entity: double } } before { subject[:description] = description } it 'copies values; does not duplicate them' do expect(obj_cloned[:description]).to eq description end end end end end end grape-0.16.2/spec/grape/util/inheritable_setting_spec.rb0000644000004100000410000002066312706307017023327 0ustar www-datawww-datarequire 'spec_helper' module Grape module Util describe InheritableSetting do before :each do InheritableSetting.reset_global! end let(:parent) do Grape::Util::InheritableSetting.new.tap do |settings| settings.global[:global_thing] = :global_foo_bar settings.namespace[:namespace_thing] = :namespace_foo_bar settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar settings.route[:route_thing] = :route_foo_bar end end let(:other_parent) do Grape::Util::InheritableSetting.new.tap do |settings| settings.namespace[:namespace_thing] = :namespace_foo_bar_other settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar_other settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar_other settings.route[:route_thing] = :route_foo_bar_other end end before :each do subject.inherit_from parent end describe '#global' do it 'sets a global value' do subject.global[:some_thing] = :foo_bar expect(subject.global[:some_thing]).to eq :foo_bar subject.global[:some_thing] = :foo_bar_next expect(subject.global[:some_thing]).to eq :foo_bar_next end it 'sets the global inherited values' do expect(subject.global[:global_thing]).to eq :global_foo_bar end it 'overrides global values' do subject.global[:global_thing] = :global_new_foo_bar expect(parent.global[:global_thing]).to eq :global_new_foo_bar end it 'should handle different parents' do subject.global[:global_thing] = :global_new_foo_bar subject.inherit_from other_parent expect(parent.global[:global_thing]).to eq :global_new_foo_bar expect(other_parent.global[:global_thing]).to eq :global_new_foo_bar end end describe '#api_class' do it 'is specific to the class' do subject.api_class[:some_thing] = :foo_bar parent.api_class[:some_thing] = :some_thing expect(subject.api_class[:some_thing]).to eq :foo_bar expect(parent.api_class[:some_thing]).to eq :some_thing end end describe '#namespace' do it 'sets a value until the end of a namespace' do subject.namespace[:some_thing] = :foo_bar expect(subject.namespace[:some_thing]).to eq :foo_bar end it 'uses new values when a new namespace starts' do subject.namespace[:namespace_thing] = :new_namespace_foo_bar expect(subject.namespace[:namespace_thing]).to eq :new_namespace_foo_bar expect(parent.namespace[:namespace_thing]).to eq :namespace_foo_bar end end describe '#namespace_inheritable' do it 'works with inheritable values' do expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar end it 'should handle different parents' do expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar subject.inherit_from other_parent expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar_other subject.inherit_from parent expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar subject.inherit_from other_parent subject.namespace_inheritable[:namespace_inheritable_thing] = :my_thing expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing subject.inherit_from parent expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing end end describe '#namespace_stackable' do it 'works with stackable values' do expect(subject.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar] subject.inherit_from other_parent expect(subject.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar_other] end end describe '#route' do it 'sets a value until the next route' do subject.route[:some_thing] = :foo_bar expect(subject.route[:some_thing]).to eq :foo_bar subject.route_end expect(subject.route[:some_thing]).to be_nil end it 'works with route values' do expect(subject.route[:route_thing]).to eq :route_foo_bar end end describe '#api_class' do it 'is specific to the class' do subject.api_class[:some_thing] = :foo_bar expect(subject.api_class[:some_thing]).to eq :foo_bar end end describe '#inherit_from' do it 'notifies clones' do new_settings = subject.point_in_time_copy expect(new_settings).to receive(:inherit_from).with(other_parent) subject.inherit_from other_parent end end describe '#point_in_time_copy' do let!(:cloned_obj) { subject.point_in_time_copy } it 'resets point_in_time_copies' do expect(cloned_obj.point_in_time_copies).to be_empty end it 'decouples namespace values' do subject.namespace[:namespace_thing] = :namespace_foo_bar cloned_obj.namespace[:namespace_thing] = :new_namespace_foo_bar expect(subject.namespace[:namespace_thing]).to eq :namespace_foo_bar end it 'decouples namespace inheritable values' do expect(cloned_obj.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar subject.namespace_inheritable[:namespace_inheritable_thing] = :my_thing expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing expect(cloned_obj.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar cloned_obj.namespace_inheritable[:namespace_inheritable_thing] = :my_cloned_thing expect(cloned_obj.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_cloned_thing expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing end it 'decouples namespace stackable values' do expect(cloned_obj.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar] subject.namespace_stackable[:namespace_stackable_thing] = :other_thing expect(subject.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar, :other_thing] expect(cloned_obj.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar] end it 'decouples route values' do expect(cloned_obj.route[:route_thing]).to eq :route_foo_bar subject.route[:route_thing] = :new_route_foo_bar expect(cloned_obj.route[:route_thing]).to eq :route_foo_bar end it 'adds itself to original as clone' do expect(subject.point_in_time_copies).to include(cloned_obj) end end describe '#to_hash' do it 'return all settings as a hash' do subject.global[:global_thing] = :global_foo_bar subject.namespace[:namespace_thing] = :namespace_foo_bar subject.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar subject.namespace_stackable[:namespace_stackable_thing] = [:namespace_stackable_foo_bar] subject.route[:route_thing] = :route_foo_bar expect(subject.to_hash).to include(global: { global_thing: :global_foo_bar }) expect(subject.to_hash).to include(namespace: { namespace_thing: :namespace_foo_bar }) expect(subject.to_hash).to include(namespace_inheritable: { namespace_inheritable_thing: :namespace_inheritable_foo_bar }) expect(subject.to_hash).to include(namespace_stackable: { namespace_stackable_thing: [:namespace_stackable_foo_bar, [:namespace_stackable_foo_bar]] }) expect(subject.to_hash).to include(route: { route_thing: :route_foo_bar }) end end end end end grape-0.16.2/spec/grape/util/stackable_values_spec.rb0000644000004100000410000000753412706307017022616 0ustar www-datawww-datarequire 'spec_helper' module Grape module Util describe StackableValues do let(:parent) { StackableValues.new } subject { StackableValues.new(parent) } describe '#keys' do it 'returns all key' do subject[:some_thing] = :foo_bar subject[:some_thing_else] = :foo_bar expect(subject.keys).to eq [:some_thing, :some_thing_else].sort end it 'returns merged keys with parent' do parent[:some_thing] = :foo parent[:some_thing_else] = :foo subject[:some_thing] = :foo_bar subject[:some_thing_more] = :foo_bar expect(subject.keys).to eq [:some_thing, :some_thing_else, :some_thing_more].sort end end describe '#delete' do it 'deletes a key' do subject[:some_thing] = :new_foo_bar subject.delete :some_thing expect(subject[:some_thing]).to eq [] end it 'does not delete parent values' do parent[:some_thing] = :foo subject[:some_thing] = :new_foo_bar subject.delete :some_thing expect(subject[:some_thing]).to eq [:foo] end end describe '#[]' do it 'returns an array of values' do subject[:some_thing] = :foo expect(subject[:some_thing]).to eq [:foo] end it 'returns parent value when no value is set' do parent[:some_thing] = :foo expect(subject[:some_thing]).to eq [:foo] end it 'combines parent and actual values' do parent[:some_thing] = :foo subject[:some_thing] = :foo_bar expect(subject[:some_thing]).to eq [:foo, :foo_bar] end it 'parent values are not changed' do parent[:some_thing] = :foo subject[:some_thing] = :foo_bar expect(parent[:some_thing]).to eq [:foo] end end describe '#[]=' do it 'sets a value' do subject[:some_thing] = :foo expect(subject[:some_thing]).to eq [:foo] end it 'pushes further values' do subject[:some_thing] = :foo subject[:some_thing] = :bar expect(subject[:some_thing]).to eq [:foo, :bar] end it 'can handle array values' do subject[:some_thing] = :foo subject[:some_thing] = [:bar, :more] expect(subject[:some_thing]).to eq [:foo, [:bar, :more]] parent[:some_thing_else] = [:foo, :bar] subject[:some_thing_else] = [:some, :bar, :foo] expect(subject[:some_thing_else]).to eq [[:foo, :bar], [:some, :bar, :foo]] end end describe '#to_hash' do it 'returns a Hash representation' do parent[:some_thing] = :foo subject[:some_thing] = [:bar, :more] subject[:some_thing_more] = :foo_bar expect(subject.to_hash).to eq(some_thing: [:foo, [:bar, :more]], some_thing_more: [:foo_bar]) end end describe '#clone' do let(:obj_cloned) { subject.clone } it 'copies all values' do parent = StackableValues.new child = StackableValues.new parent grandchild = StackableValues.new child parent[:some_thing] = :foo child[:some_thing] = [:bar, :more] grandchild[:some_thing] = :grand_foo_bar grandchild[:some_thing_more] = :foo_bar expect(grandchild.clone.to_hash).to eq(some_thing: [:foo, [:bar, :more], :grand_foo_bar], some_thing_more: [:foo_bar]) end context 'complex (i.e. not primitive) data types (ex. middleware, please see bug #930)' do let(:middleware) { double } before { subject[:middleware] = middleware } it 'copies values; does not duplicate them' do expect(obj_cloned[:middleware]).to eq [middleware] end end end end end end grape-0.16.2/spec/grape/util/strict_hash_configuration_spec.rb0000644000004100000410000000172612706307017024545 0ustar www-datawww-datarequire 'spec_helper' module Grape module Util describe 'StrictHashConfiguration' do subject do Class.new do include Grape::Util::StrictHashConfiguration.module(:config1, :config2, config3: [:config4], config5: [config6: [:config7, :config8]]) end end it 'set nested configs' do subject.configure do config1 'alpha' config2 'beta' config3 do config4 'gamma' end local_var = 8 config5 do config6 do config7 7 config8 local_var end end end expect(subject.settings).to eq(config1: 'alpha', config2: 'beta', config3: { config4: 'gamma' }, config5: { config6: { config7: 7, config8: 8 } } ) end end end end grape-0.16.2/spec/grape/path_spec.rb0000644000004100000410000001635212706307017017263 0ustar www-datawww-datarequire 'spec_helper' module Grape describe Path do describe '#initialize' do it 'remembers the path' do path = Path.new('/:id', anything, anything) expect(path.raw_path).to eql('/:id') end it 'remembers the namespace' do path = Path.new(anything, '/users', anything) expect(path.namespace).to eql('/users') end it 'remebers the settings' do path = Path.new(anything, anything, foo: 'bar') expect(path.settings).to eql(foo: 'bar') end end describe '#mount_path' do it 'is nil when no mount path setting exists' do path = Path.new(anything, anything, {}) expect(path.mount_path).to be_nil end it 'is nil when the mount path is nil' do path = Path.new(anything, anything, mount_path: nil) expect(path.mount_path).to be_nil end it 'splits the mount path' do path = Path.new(anything, anything, mount_path: %w(foo bar)) expect(path.mount_path).to eql(%w(foo bar)) end end describe '#root_prefix' do it 'is nil when no root prefix setting exists' do path = Path.new(anything, anything, {}) expect(path.root_prefix).to be_nil end it 'is nil when the mount path is nil' do path = Path.new(anything, anything, root_prefix: nil) expect(path.root_prefix).to be_nil end it 'splits the mount path' do path = Path.new(anything, anything, root_prefix: 'hello/world') expect(path.root_prefix).to eql(%w(hello world)) end end describe '#uses_path_versioning?' do it 'is false when the version setting is nil' do path = Path.new(anything, anything, version: nil) expect(path.uses_path_versioning?).to be false end it 'is false when the version option is header' do path = Path.new( anything, anything, version: 'v1', version_options: { using: :header } ) expect(path.uses_path_versioning?).to be false end it 'is true when the version option is path' do path = Path.new( anything, anything, version: 'v1', version_options: { using: :path } ) expect(path.uses_path_versioning?).to be true end end describe '#namespace?' do it 'is false when the namespace is nil' do path = Path.new(anything, nil, anything) expect(path.namespace?).to be nil end it 'is false when the namespace starts with whitespace' do path = Path.new(anything, ' /foo', anything) expect(path.namespace?).to be nil end it 'is false when the namespace is the root path' do path = Path.new(anything, '/', anything) expect(path.namespace?).to be false end it 'is true otherwise' do path = Path.new(anything, '/world', anything) expect(path.namespace?).to be true end end describe '#path?' do it 'is false when the path is nil' do path = Path.new(nil, anything, anything) expect(path.path?).to be nil end it 'is false when the path starts with whitespace' do path = Path.new(' /foo', anything, anything) expect(path.path?).to be nil end it 'is false when the path is the root path' do path = Path.new('/', anything, anything) expect(path.path?).to be false end it 'is true otherwise' do path = Path.new('/hello', anything, anything) expect(path.path?).to be true end end describe '#path' do context 'mount_path' do it 'is not included when it is nil' do path = Path.new(nil, nil, mount_path: '/foo/bar') expect(path.path).to eql '/foo/bar' end it 'is included when it is not nil' do path = Path.new(nil, nil, {}) expect(path.path).to eql('/') end end context 'root_prefix' do it 'is not included when it is nil' do path = Path.new(nil, nil, {}) expect(path.path).to eql('/') end it 'is included after the mount path' do path = Path.new( nil, nil, mount_path: '/foo', root_prefix: '/hello' ) expect(path.path).to eql('/foo/hello') end end it 'uses the namespace after the mount path and root prefix' do path = Path.new( nil, 'namespace', mount_path: '/foo', root_prefix: '/hello' ) expect(path.path).to eql('/foo/hello/namespace') end it 'uses the raw path after the namespace' do path = Path.new( 'raw_path', 'namespace', mount_path: '/foo', root_prefix: '/hello' ) expect(path.path).to eql('/foo/hello/namespace/raw_path') end end describe '#suffix' do context 'when using a specific format' do it 'accepts specified format' do path = Path.new(nil, nil, {}) allow(path).to receive(:uses_specific_format?) { true } allow(path).to receive(:settings) { { format: :json } } expect(path.suffix).to eql('(.json)') end end context 'when path versioning is used' do it "includes a '/'" do path = Path.new(nil, nil, {}) allow(path).to receive(:uses_specific_format?) { false } allow(path).to receive(:uses_path_versioning?) { true } expect(path.suffix).to eql('(/.:format)') end end context 'when path versioning is not used' do it "does not include a '/' when the path has a namespace" do path = Path.new(nil, 'namespace', {}) allow(path).to receive(:uses_specific_format?) { false } allow(path).to receive(:uses_path_versioning?) { true } expect(path.suffix).to eql('(.:format)') end it "does not include a '/' when the path has a path" do path = Path.new('/path', nil, {}) allow(path).to receive(:uses_specific_format?) { false } allow(path).to receive(:uses_path_versioning?) { true } expect(path.suffix).to eql('(.:format)') end it "includes a '/' otherwise" do path = Path.new(nil, nil, {}) allow(path).to receive(:uses_specific_format?) { false } allow(path).to receive(:uses_path_versioning?) { true } expect(path.suffix).to eql('(/.:format)') end end end describe '#path_with_suffix' do it 'combines the path and suffix' do path = Path.new(nil, nil, {}) allow(path).to receive(:path) { '/the/path' } allow(path).to receive(:suffix) { 'suffix' } expect(path.path_with_suffix).to eql('/the/pathsuffix') end context 'when using a specific format' do it 'might have a suffix with specified format' do path = Path.new(nil, nil, {}) allow(path).to receive(:path) { '/the/path' } allow(path).to receive(:uses_specific_format?) { true } allow(path).to receive(:settings) { { format: :json } } expect(path.path_with_suffix).to eql('/the/path(.json)') end end end end end grape-0.16.2/spec/grape/loading_spec.rb0000644000004100000410000000145212706307016017736 0ustar www-datawww-datarequire 'spec_helper' describe Grape::API do let(:jobs_api) do Class.new(Grape::API) do namespace :one do namespace :two do namespace :three do get :one do end get :two do end end end end end end let(:combined_api) do JobsApi = jobs_api Class.new(Grape::API) do version :v1, using: :accept_version_header, cascade: true mount JobsApi end end subject do CombinedApi = combined_api Class.new(Grape::API) do format :json mount CombinedApi => '/' end end def app subject end it 'execute first request in reasonable time' do started = Time.now get '/mount1/nested/test_method' expect(Time.now - started).to be < 5 end end grape-0.16.2/spec/grape/request_spec.rb0000644000004100000410000000434712706307017020020 0ustar www-datawww-datarequire 'spec_helper' module Grape describe Request do let(:default_method) { 'GET' } let(:default_params) { {} } let(:default_options) { { method: method, params: params } } let(:default_env) { Rack::MockRequest.env_for('/', options) } let(:method) { default_method } let(:params) { default_params } let(:options) { default_options } let(:env) { default_env } let(:request) { Grape::Request.new(env) } describe '#params' do let(:params) { { a: '123', b: 'xyz' } } it 'returns params' do expect(request.params).to eq('a' => '123', 'b' => 'xyz') end describe 'with grape.routing_args' do let(:options) { default_options.merge('grape.routing_args' => routing_args) } let(:routing_args) { { version: '123', route_info: '456', c: 'ccc' } } it 'cuts version and route_info' do expect(request.params).to eq('a' => '123', 'b' => 'xyz', 'c' => 'ccc') end end end describe '#headers' do let(:options) { default_options.merge(request_headers) } describe 'with http headers in env' do let(:request_headers) { { 'HTTP_X_GRAPE_IS_COOL' => 'yeah' } } it 'cuts HTTP_ prefix and capitalizes header name words' do expect(request.headers).to eq('X-Grape-Is-Cool' => 'yeah') end end describe 'with non-HTTP_* stuff in env' do let(:request_headers) { { 'HTP_X_GRAPE_ENTITY_TOO' => 'but now we are testing Grape' } } it 'does not include them' do expect(request.headers).to eq({}) end end describe 'with symbolic header names' do let(:request_headers) { { HTTP_GRAPE_LIKES_SYMBOLIC: 'it is true' } } let(:env) { default_env.merge(request_headers) } it 'converts them to string' do expect(request.headers).to eq('Grape-Likes-Symbolic' => 'it is true') end end end end end grape-0.16.2/spec/spec_helper.rb0000644000004100000410000000124112706307017016477 0ustar www-datawww-data$LOAD_PATH.unshift(File.dirname(__FILE__)) $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support')) require 'grape' require 'rubygems' require 'bundler' Bundler.setup :default, :test require 'json' require 'rack/test' require 'base64' require 'cookiejar' require 'mime/types' require 'cgi' Dir["#{File.dirname(__FILE__)}/support/*.rb"].each do |file| require file end I18n.enforce_available_locales = false RSpec.configure do |config| config.include Rack::Test::Methods config.raise_errors_for_deprecations! config.before(:each) { Grape::Util::InheritableSetting.reset_global! } end grape-0.16.2/spec/shared/0000755000004100000410000000000012706307017015131 5ustar www-datawww-datagrape-0.16.2/spec/shared/versioning_examples.rb0000644000004100000410000001105312706307017021537 0ustar www-datawww-datashared_examples_for 'versioning' do it 'sets the API version' do subject.format :txt subject.version 'v1', macro_options subject.get :hello do "Version: #{request.env['api.version']}" end versioned_get '/hello', 'v1', macro_options expect(last_response.body).to eql 'Version: v1' end it 'adds the prefix before the API version' do subject.format :txt subject.prefix 'api' subject.version 'v1', macro_options subject.get :hello do "Version: #{request.env['api.version']}" end versioned_get '/hello', 'v1', macro_options.merge(prefix: 'api') expect(last_response.body).to eql 'Version: v1' end it 'is able to specify version as a nesting' do subject.version 'v2', macro_options subject.get '/awesome' do 'Radical' end subject.version 'v1', macro_options do get '/legacy' do 'Totally' end end versioned_get '/awesome', 'v1', macro_options expect(last_response.status).to eql 404 versioned_get '/awesome', 'v2', macro_options expect(last_response.status).to eql 200 versioned_get '/legacy', 'v1', macro_options expect(last_response.status).to eql 200 versioned_get '/legacy', 'v2', macro_options expect(last_response.status).to eql 404 end it 'is able to specify multiple versions' do subject.version 'v1', 'v2', macro_options subject.get 'awesome' do 'I exist' end versioned_get '/awesome', 'v1', macro_options expect(last_response.status).to eql 200 versioned_get '/awesome', 'v2', macro_options expect(last_response.status).to eql 200 versioned_get '/awesome', 'v3', macro_options expect(last_response.status).to eql 404 end context 'with different versions for the same endpoint' do context 'without a prefix' do it 'allows the same endpoint to be implemented' do subject.format :txt subject.version 'v2', macro_options subject.get 'version' do request.env['api.version'] end subject.version 'v1', macro_options do get 'version' do 'version ' + request.env['api.version'] end end versioned_get '/version', 'v2', macro_options expect(last_response.status).to eq(200) expect(last_response.body).to eq('v2') versioned_get '/version', 'v1', macro_options expect(last_response.status).to eq(200) expect(last_response.body).to eq('version v1') end end context 'with a prefix' do it 'allows the same endpoint to be implemented' do subject.format :txt subject.prefix 'api' subject.version 'v2', macro_options subject.get 'version' do request.env['api.version'] end subject.version 'v1', macro_options do get 'version' do 'version ' + request.env['api.version'] end end versioned_get '/version', 'v1', macro_options.merge(prefix: subject.prefix) expect(last_response.status).to eq(200) expect(last_response.body).to eq('version v1') versioned_get '/version', 'v2', macro_options.merge(prefix: subject.prefix) expect(last_response.status).to eq(200) expect(last_response.body).to eq('v2') end end end context 'with before block defined within a version block' do it 'calls before block that is defined within the version block' do subject.format :txt subject.prefix 'api' subject.version 'v2', macro_options do before do @output ||= 'v2-' end get 'version' do @output += 'version' end end subject.version 'v1', macro_options do before do @output ||= 'v1-' end get 'version' do @output += 'version' end end versioned_get '/version', 'v1', macro_options.merge(prefix: subject.prefix) expect(last_response.status).to eq(200) expect(last_response.body).to eq('v1-version') versioned_get '/version', 'v2', macro_options.merge(prefix: subject.prefix) expect(last_response.status).to eq(200) expect(last_response.body).to eq('v2-version') end end it 'does not overwrite version parameter with API version' do subject.format :txt subject.version 'v1', macro_options subject.params { requires :version } subject.get :api_version_with_version_param do params[:version] end versioned_get '/api_version_with_version_param?version=1', 'v1', macro_options expect(last_response.body).to eql '1' end end grape-0.16.2/spec/support/0000755000004100000410000000000012706307017015377 5ustar www-datawww-datagrape-0.16.2/spec/support/endpoint_faker.rb0000644000004100000410000000070612706307017020717 0ustar www-datawww-datamodule Spec module Support class EndpointFaker class FakerAPI < Grape::API get '/' do end end def initialize(app, endpoint = FakerAPI.endpoints.first) @app = app @endpoint = endpoint end def call(env) @endpoint.instance_exec do @request = Grape::Request.new(env.dup) end @app.call(env.merge('api.endpoint' => @endpoint)) end end end end grape-0.16.2/spec/support/versioned_helpers.rb0000644000004100000410000000265712706307017021456 0ustar www-datawww-data# Versioning # Returns the path with options[:version] prefixed if options[:using] is :path. # Returns normal path otherwise. def versioned_path(options = {}) case options[:using] when :path File.join('/', options[:prefix] || '', options[:version], options[:path]) when :param File.join('/', options[:prefix] || '', options[:path]) when :header File.join('/', options[:prefix] || '', options[:path]) when :accept_version_header File.join('/', options[:prefix] || '', options[:path]) else fail ArgumentError.new("unknown versioning strategy: #{options[:using]}") end end def versioned_headers(options) case options[:using] when :path {} # no-op when :param {} # no-op when :header { 'HTTP_ACCEPT' => [ "application/vnd.#{options[:vendor]}-#{options[:version]}", options[:format] ].compact.join('+') } when :accept_version_header { 'HTTP_ACCEPT_VERSION' => "#{options[:version]}" } else fail ArgumentError.new("unknown versioning strategy: #{options[:using]}") end end def versioned_get(path, version_name, version_options = {}) path = versioned_path(version_options.merge(version: version_name, path: path)) headers = versioned_headers(version_options.merge(version: version_name)) params = {} if version_options[:using] == :param params = { version_options[:parameter] => version_name } end get path, params, headers end grape-0.16.2/spec/support/content_type_helpers.rb0000644000004100000410000000050312706307017022157 0ustar www-datawww-datamodule ContentTypeHelpers %w(put patch post delete).each do |method| define_method :"#{method}_with_json" do |uri, params = {}, env = {}, &block| params = params.to_json env['CONTENT_TYPE'] ||= 'application/json' send(method, uri, params, env, &block) end end end include(ContentTypeHelpers) grape-0.16.2/spec/support/basic_auth_encode_helpers.rb0000644000004100000410000000014612706307017023066 0ustar www-datawww-datadef encode_basic_auth(username, password) 'Basic ' + Base64.encode64("#{username}:#{password}") end grape-0.16.2/spec/support/file_streamer.rb0000644000004100000410000000027012706307017020544 0ustar www-datawww-dataclass FileStreamer def initialize(file_path) @file_path = file_path end def each(&blk) File.open(@file_path, 'rb') do |file| file.each(10, &blk) end end end grape-0.16.2/benchmark/0000755000004100000410000000000012706307016014662 5ustar www-datawww-datagrape-0.16.2/benchmark/simple.rb0000644000004100000410000000065012706307016016501 0ustar www-datawww-data$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) require 'grape' require 'benchmark/ips' class API < Grape::API prefix :api version 'v1', using: :path get '/' do 'hello' end end options = { method: 'GET' } env = Rack::MockRequest.env_for('/api/v1', options) 10.times do |i| env["HTTP_HEADER#{i}"] = '123' end Benchmark.ips do |ips| ips.report('simple') do API.call env end end grape-0.16.2/lib/0000755000004100000410000000000012706307016013476 5ustar www-datawww-datagrape-0.16.2/lib/grape/0000755000004100000410000000000012706307016014574 5ustar www-datawww-datagrape-0.16.2/lib/grape/middleware/0000755000004100000410000000000012706307016016711 5ustar www-datawww-datagrape-0.16.2/lib/grape/middleware/formatter.rb0000644000004100000410000001313512706307016021244 0ustar www-datawww-datarequire 'grape/middleware/base' module Grape module Middleware class Formatter < Base CHUNKED = 'chunked'.freeze def default_options { default_format: :txt, formatters: {}, parsers: {} } end def before negotiate_content_type read_body_input end def after return unless @app_response status, headers, bodies = *@app_response if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) @app_response else build_formatted_response(status, headers, bodies) end end private def build_formatted_response(status, headers, bodies) headers = ensure_content_type(headers) if bodies.is_a?(Grape::ServeFile::FileResponse) Grape::ServeFile::SendfileResponse.new([], status, headers) do |resp| resp.body = bodies.file end else # Allow content-type to be explicitly overwritten formatter = fetch_formatter(headers, options) bodymap = bodies.collect { |body| formatter.call(body, env) } Rack::Response.new(bodymap, status, headers) end rescue Grape::Exceptions::InvalidFormatter => e throw :error, status: 500, message: e.message end def fetch_formatter(headers, options) api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT] Grape::Formatter.formatter_for(api_format, options) end # Set the content type header for the API format if it is not already present. # # @param headers [Hash] # @return [Hash] def ensure_content_type(headers) if headers[Grape::Http::Headers::CONTENT_TYPE] headers else headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT])) end end def request @request ||= Rack::Request.new(env) end # store read input in env['api.request.input'] def read_body_input return unless (request.post? || request.put? || request.patch? || request.delete?) && (!request.form_data? || !request.media_type) && (!request.parseable_data?) && (request.content_length.to_i > 0 || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED) return unless (input = env[Grape::Env::RACK_INPUT]) input.rewind body = env[Grape::Env::API_REQUEST_INPUT] = input.read begin read_rack_input(body) if body && body.length > 0 ensure input.rewind end end # store parsed input in env['api.request.body'] def read_rack_input(body) fmt = mime_types[request.media_type] if request.media_type fmt ||= options[:default_format] if content_type_for(fmt) parser = Grape::Parser.parser_for fmt, options if parser begin body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env)) if body.is_a?(Hash) if env[Grape::Env::RACK_REQUEST_FORM_HASH] env[Grape::Env::RACK_REQUEST_FORM_HASH] = env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body) else env[Grape::Env::RACK_REQUEST_FORM_HASH] = body end env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT] end rescue Grape::Exceptions::Base => e raise e rescue StandardError => e throw :error, status: 400, message: e.message end else env[Grape::Env::API_REQUEST_BODY] = body end else throw :error, status: 406, message: "The requested content-type '#{request.media_type}' is not supported." end end def negotiate_content_type fmt = format_from_extension || format_from_params || options[:format] || format_from_header || options[:default_format] if content_type_for(fmt) env[Grape::Env::API_FORMAT] = fmt else throw :error, status: 406, message: "The requested format '#{fmt}' is not supported." end end def format_from_extension parts = request.path.split('.') if parts.size > 1 extension = parts.last # avoid symbol memory leak on an unknown format return extension.to_sym if content_type_for(extension) end nil end def format_from_params fmt = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[Grape::Http::Headers::FORMAT] # avoid symbol memory leak on an unknown format return fmt.to_sym if content_type_for(fmt) fmt end def format_from_header mime_array.each do |t| return mime_types[t] if mime_types.key?(t) end nil end def mime_array accept = env[Grape::Http::Headers::HTTP_ACCEPT] return [] unless accept accept_into_mime_and_quality = %r{ ( \w+/[\w+.-]+) # eg application/vnd.example.myformat+xml (?: (?:;[^,]*?)? # optionally multiple formats in a row ;\s*q=([\d.]+) # optional "quality" preference (eg q=0.5) )? }x vendor_prefix_pattern = /vnd\.[^+]+\+/ accept.scan(accept_into_mime_and_quality) .sort_by { |_, quality_preference| -quality_preference.to_f } .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] } end end end end grape-0.16.2/lib/grape/middleware/versioner/0000755000004100000410000000000012706307016020725 5ustar www-datawww-datagrape-0.16.2/lib/grape/middleware/versioner/path.rb0000644000004100000410000000266012706307016022212 0ustar www-datawww-datarequire 'grape/middleware/base' module Grape module Middleware module Versioner # This middleware sets various version related rack environment variables # based on the uri path and removes the version substring from the uri # path. If the version substring does not match any potential initialized # versions, a 404 error is thrown. # # Example: For a uri path # /v1/resource # # The following rack env variables are set and path is rewritten to # '/resource': # # env['api.version'] => 'v1' # class Path < Base def default_options { pattern: /.*/i } end def before path = env[Grape::Http::Headers::PATH_INFO].dup if prefix && path.index(prefix) == 0 path.sub!(prefix, '') path = Grape::Router.normalize_path(path) end pieces = path.split('/') potential_version = pieces[1] return unless potential_version =~ options[:pattern] throw :error, status: 404, message: '404 API Version Not Found' if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version } env[Grape::Env::API_VERSION] = potential_version end private def prefix Grape::Router.normalize_path(options[:prefix].to_s) if options[:prefix] end end end end end grape-0.16.2/lib/grape/middleware/versioner/param.rb0000644000004100000410000000331512706307016022354 0ustar www-datawww-datarequire 'grape/middleware/base' module Grape module Middleware module Versioner # This middleware sets various version related rack environment variables # based on the request parameters and removes that parameter from the # request parameters for subsequent middleware and API. # If the version substring does not match any potential initialized # versions, a 404 error is thrown. # If the version substring is not passed the version (highest mounted) # version will be used. # # Example: For a uri path # /resource?apiver=v1 # # The following rack env variables are set and path is rewritten to # '/resource': # # env['api.version'] => 'v1' class Param < Base def default_options { version_options: { parameter: 'apiver'.freeze } } end def before potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey] return if potential_version.nil? throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' } if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version } env[Grape::Env::API_VERSION] = potential_version env[Grape::Env::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Grape::Env::RACK_REQUEST_QUERY_HASH end private def paramkey version_options[:parameter] || default_options[:version_options][:parameter] end def version_options options[:version_options] end end end end end grape-0.16.2/lib/grape/middleware/versioner/header.rb0000644000004100000410000001504312706307016022505 0ustar www-datawww-datarequire 'grape/middleware/base' require 'grape/middleware/versioner/parse_media_type_patch' module Grape module Middleware module Versioner # This middleware sets various version related rack environment variables # based on the HTTP Accept header with the pattern: # application/vnd.:vendor-:version+:format # # Example: For request header # Accept: application/vnd.mycompany.a-cool-resource-v1+json # # The following rack env variables are set: # # env['api.type'] => 'application' # env['api.subtype'] => 'vnd.mycompany.a-cool-resource-v1+json' # env['api.vendor] => 'mycompany.a-cool-resource' # env['api.version] => 'v1' # env['api.format] => 'json' # # If version does not match this route, then a 406 is raised with # X-Cascade header to alert Grape::Router to attempt the next matched # route. class Header < Base VENDOR_VERSION_HEADER_REGEX = /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/ HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#\$&\^]+/ HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))+/ def before strict_header_checks if strict? if media_type || env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED] media_type_header_handler elsif headers_contain_wrong_vendor? fail_with_invalid_accept_header!('API vendor not found.') elsif headers_contain_wrong_version? fail_with_invalid_version_header!('API version not found.') end end private def strict_header_checks strict_accept_header_presence_check strict_version_vendor_accept_header_presence_check end def strict_accept_header_presence_check return unless header.qvalues.empty? fail_with_invalid_accept_header!('Accept header must be set.') end def strict_version_vendor_accept_header_presence_check return unless versions.present? return if an_accept_header_with_version_and_vendor_is_present? fail_with_invalid_accept_header!('API vendor or version not found.') end def an_accept_header_with_version_and_vendor_is_present? header.qvalues.keys.any? do |h| VENDOR_VERSION_HEADER_REGEX =~ h.sub('application/', '') end end def header @header ||= rack_accept_header end def media_type @media_type ||= header.best_of(available_media_types) end def media_type_header_handler type, subtype = Rack::Accept::Header.parse_media_type(media_type) env[Grape::Env::API_TYPE] = type env[Grape::Env::API_SUBTYPE] = subtype return unless VENDOR_VERSION_HEADER_REGEX =~ subtype env[Grape::Env::API_VENDOR] = Regexp.last_match[1] env[Grape::Env::API_VERSION] = Regexp.last_match[2] # weird that Grape::Middleware::Formatter also does this env[Grape::Env::API_FORMAT] = Regexp.last_match[3] end def fail_with_invalid_accept_header!(message) fail Grape::Exceptions::InvalidAcceptHeader .new(message, error_headers) end def fail_with_invalid_version_header!(message) fail Grape::Exceptions::InvalidVersionHeader .new(message, error_headers) end def available_media_types available_media_types = [] content_types.each do |extension, _media_type| versions.reverse_each do |version| available_media_types += [ "application/vnd.#{vendor}-#{version}+#{extension}", "application/vnd.#{vendor}-#{version}" ] end available_media_types << "application/vnd.#{vendor}+#{extension}" end available_media_types << "application/vnd.#{vendor}" content_types.each do |_, media_type| available_media_types << media_type end available_media_types.flatten end def headers_contain_wrong_vendor? header.values.all? do |header_value| vendor?(header_value) && request_vendor(header_value) != vendor end end def headers_contain_wrong_version? header.values.all? do |header_value| version?(header_value) && !versions.include?(request_version(header_value)) end end def rack_accept_header Rack::Accept::MediaType.new env[Grape::Http::Headers::HTTP_ACCEPT] rescue RuntimeError => e fail_with_invalid_accept_header!(e.message) end def versions options[:versions] || [] end def vendor version_options && version_options[:vendor] end def strict? version_options && version_options[:strict] end def version_options options[:version_options] end # By default those errors contain an `X-Cascade` header set to `pass`, # which allows nesting and stacking of routes # (see Grape::Router for more # information). To prevent # this behavior, and not add the `X-Cascade` # header, one can set the `:cascade` option to `false`. def cascade? if version_options && version_options.key?(:cascade) !!version_options[:cascade] else true end end def error_headers cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {} end # @param [String] media_type a content type # @return [Boolean] whether the content type sets a vendor def vendor?(media_type) _, subtype = Rack::Accept::Header.parse_media_type(media_type) subtype[HAS_VENDOR_REGEX] end def request_vendor(media_type) _, subtype = Rack::Accept::Header.parse_media_type(media_type) subtype.match(VENDOR_VERSION_HEADER_REGEX)[1] end def request_version(media_type) _, subtype = Rack::Accept::Header.parse_media_type(media_type) subtype.match(VENDOR_VERSION_HEADER_REGEX)[2] end # @param [String] media_type a content type # @return [Boolean] whether the content type sets an API version def version?(media_type) _, subtype = Rack::Accept::Header.parse_media_type(media_type) subtype[HAS_VERSION_REGEX] end end end end end grape-0.16.2/lib/grape/middleware/versioner/parse_media_type_patch.rb0000644000004100000410000000117312706307016025745 0ustar www-datawww-datamodule Rack module Accept module Header class << self # Corrected version of https://github.com/mjackson/rack-accept/blob/master/lib/rack/accept/header.rb#L40-L44 def parse_media_type(media_type) # see http://tools.ietf.org/html/rfc6838#section-4.2 for allowed characters in media type names m = media_type.to_s.match(%r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$}) m ? [m[1], m[2], m[3] || ''] : [] end end end class MediaType def parse_media_type(media_type) Header.parse_media_type(media_type) end end end end grape-0.16.2/lib/grape/middleware/versioner/accept_version_header.rb0000644000004100000410000000413612706307016025572 0ustar www-datawww-datarequire 'grape/middleware/base' module Grape module Middleware module Versioner # This middleware sets various version related rack environment variables # based on the HTTP Accept-Version header # # Example: For request header # Accept-Version: v1 # # The following rack env variables are set: # # env['api.version'] => 'v1' # # If version does not match this route, then a 406 is raised with # X-Cascade header to alert Grape::Router to attempt the next matched # route. class AcceptVersionHeader < Base def before potential_version = (env[Grape::Http::Headers::HTTP_ACCEPT_VERSION] || '').strip if strict? # If no Accept-Version header: if potential_version.empty? throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.' end end return if potential_version.empty? # If the requested version is not supported: throw :error, status: 406, headers: error_headers, message: 'The requested version is not supported.' unless versions.any? { |v| v.to_s == potential_version } env[Grape::Env::API_VERSION] = potential_version end private def versions options[:versions] || [] end def strict? options[:version_options] && options[:version_options][:strict] end # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking # of routes (see Grape::Router) for more information). To prevent # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`. def cascade? if options[:version_options] && options[:version_options].key?(:cascade) !!options[:version_options][:cascade] else true end end def error_headers cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {} end end end end end grape-0.16.2/lib/grape/middleware/auth/0000755000004100000410000000000012706307016017652 5ustar www-datawww-datagrape-0.16.2/lib/grape/middleware/auth/strategy_info.rb0000644000004100000410000000046512706307016023061 0ustar www-datawww-datamodule Grape module Middleware module Auth StrategyInfo = Struct.new(:auth_class, :settings_fetcher) do def create(app, options, &block) strategy_args = settings_fetcher.call(options) auth_class.new(app, *strategy_args, &block) end end end end end grape-0.16.2/lib/grape/middleware/auth/strategies.rb0000644000004100000410000000121712706307016022352 0ustar www-datawww-datamodule Grape module Middleware module Auth module Strategies module_function def add(label, strategy, option_fetcher = ->(_) { [] }) auth_strategies[label] = StrategyInfo.new(strategy, option_fetcher) end def auth_strategies @auth_strategies ||= { http_basic: StrategyInfo.new(Rack::Auth::Basic, ->(settings) { [settings[:realm]] }), http_digest: StrategyInfo.new(Rack::Auth::Digest::MD5, ->(settings) { [settings[:realm], settings[:opaque]] }) } end def [](label) auth_strategies[label] end end end end end grape-0.16.2/lib/grape/middleware/auth/base.rb0000644000004100000410000000177312706307016021121 0ustar www-datawww-datarequire 'rack/auth/basic' module Grape module Middleware module Auth class Base attr_accessor :options, :app, :env def initialize(app, options = {}) @app = app @options = options || {} end def context env[Grape::Env::API_ENDPOINT] end def call(env) dup._call(env) end def _call(env) self.env = env if options.key?(:type) auth_proc = options[:proc] auth_proc_context = context strategy_info = Grape::Middleware::Auth::Strategies[options[:type]] throw(:error, status: 401, message: 'API Authorization Failed.') unless strategy_info.present? strategy = strategy_info.create(@app, options) do |*args| auth_proc_context.instance_exec(*args, &auth_proc) end strategy.call(env) else app.call(env) end end end end end end grape-0.16.2/lib/grape/middleware/auth/dsl.rb0000644000004100000410000000235712706307016020770 0ustar www-datawww-datarequire 'rack/auth/basic' require 'active_support/concern' module Grape module Middleware module Auth module DSL extend ActiveSupport::Concern module ClassMethods # Add an authentication type to the API. Currently # only `:http_basic`, `:http_digest` are supported. def auth(type = nil, options = {}, &block) if type namespace_inheritable(:auth, options.reverse_merge(type: type.to_sym, proc: block)) use Grape::Middleware::Auth::Base, namespace_inheritable(:auth) else namespace_inheritable(:auth) end end # Add HTTP Basic authorization to the API. # # @param [Hash] options A hash of options. # @option options [String] :realm "API Authorization" The HTTP Basic realm. def http_basic(options = {}, &block) options[:realm] ||= 'API Authorization' auth :http_basic, options, &block end def http_digest(options = {}, &block) options[:realm] ||= 'API Authorization' options[:opaque] ||= 'secret' auth :http_digest, options, &block end end end end end end grape-0.16.2/lib/grape/middleware/filter.rb0000644000004100000410000000072712706307016020531 0ustar www-datawww-datamodule Grape module Middleware # This is a simple middleware for adding before and after filters # to Grape APIs. It is used like so: # # use Grape::Middleware::Filter, before: -> { do_something }, after: -> { do_something } class Filter < Base def before app.instance_eval(&options[:before]) if options[:before] end def after app.instance_eval(&options[:after]) if options[:after] end end end end grape-0.16.2/lib/grape/middleware/globals.rb0000644000004100000410000000060712706307016020664 0ustar www-datawww-datarequire 'grape/middleware/base' module Grape module Middleware class Globals < Base def before request = Grape::Request.new(@env) @env[Grape::Env::GRAPE_REQUEST] = request @env[Grape::Env::GRAPE_REQUEST_HEADERS] = request.headers @env[Grape::Env::GRAPE_REQUEST_PARAMS] = request.params if @env[Grape::Env::RACK_INPUT] end end end end grape-0.16.2/lib/grape/middleware/versioner.rb0000644000004100000410000000157212706307016021257 0ustar www-datawww-data# Versioners set env['api.version'] when a version is defined on an API and # on the requests. The current methods for determining version are: # # :header - version from HTTP Accept header. # :path - version from uri. e.g. /v1/resource # :param - version from uri query string, e.g. /v1/resource?apiver=v1 # # See individual classes for details. module Grape module Middleware module Versioner module_function # @param strategy [Symbol] :path, :header or :param # @return a middleware class based on strategy def using(strategy) case strategy when :path Path when :header Header when :param Param when :accept_version_header AcceptVersionHeader else fail Grape::Exceptions::InvalidVersionerOption.new(strategy) end end end end end grape-0.16.2/lib/grape/middleware/base.rb0000644000004100000410000000452612706307016020157 0ustar www-datawww-datarequire 'grape/dsl/headers' module Grape module Middleware class Base attr_reader :app, :env, :options TEXT_HTML = 'text/html'.freeze include Grape::DSL::Headers # @param [Rack Application] app The standard argument for a Rack middleware. # @param [Hash] options A hash of options, simply stored for use by subclasses. def initialize(app, options = {}) @app = app @options = default_options.merge(options) end def default_options {} end def call(env) dup.call!(env) end def call!(env) @env = env before begin @app_response = @app.call(@env) ensure begin after_response = after rescue StandardError => e warn "caught error of type #{e.class} in after callback inside #{self.class.name} : #{e.message}" raise e end end response = after_response || @app_response merge_headers response response end # @abstract # Called before the application is called in the middleware lifecycle. def before end # @abstract # Called after the application is called in the middleware lifecycle. # @return [Response, nil] a Rack SPEC response or nil to call the application afterwards. def after end def response return @app_response if @app_response.is_a?(Rack::Response) Rack::Response.new(@app_response[2], @app_response[0], @app_response[1]) end def content_type_for(format) HashWithIndifferentAccess.new(content_types)[format] end def content_types ContentTypes.content_types_for(options[:content_types]) end def content_type content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || TEXT_HTML end def mime_types types_without_params = {} content_types.each_pair do |k, v| types_without_params[v.split(';').first] = k end types_without_params end private def merge_headers(response) return unless headers.is_a?(Hash) case response when Rack::Response then response.headers.merge!(headers) when Array then response[1].merge!(headers) end end end end end grape-0.16.2/lib/grape/middleware/error.rb0000644000004100000410000001011612706307016020366 0ustar www-datawww-datarequire 'grape/middleware/base' module Grape module Middleware class Error < Base def default_options { default_status: 500, # default status returned on error default_message: '', format: :txt, formatters: {}, error_formatters: {}, rescue_all: false, # true to rescue all exceptions rescue_subclasses: true, # rescue subclasses of exceptions listed rescue_options: { backtrace: false }, # true to display backtrace rescue_handlers: {}, # rescue handler blocks base_only_rescue_handlers: {}, # rescue handler blocks rescuing only the base class all_rescue_handler: nil # rescue handler block to rescue from all exceptions } end def call!(env) @env = env inject_helpers! begin error_response(catch(:error) do return @app.call(@env) end) rescue StandardError => e is_rescuable = rescuable?(e.class) if e.is_a?(Grape::Exceptions::Base) && !is_rescuable handler = ->(arg) { error_response(arg) } else raise unless is_rescuable handler = find_handler(e.class) end handler.nil? ? handle_error(e) : exec_handler(e, &handler) end end def find_handler(klass) handler = options[:rescue_handlers].find(-> { [] }) { |error, _| klass <= error }[1] handler ||= options[:base_only_rescue_handlers][klass] handler ||= options[:all_rescue_handler] with_option = options[:rescue_options][:with] if with_option.instance_of?(Symbol) if respond_to?(with_option) handler ||= self.class.instance_method(with_option).bind(self) else fail NoMethodError, "undefined method `#{with_option}'" end end handler end def rescuable?(klass) return false if klass == Grape::Exceptions::InvalidVersionHeader options[:rescue_all] || (options[:rescue_handlers] || []).any? { |error, _handler| klass <= error } || (options[:base_only_rescue_handlers] || []).include?(klass) end def exec_handler(e, &handler) if handler.lambda? && handler.arity == 0 instance_exec(&handler) else instance_exec(e, &handler) end end def inject_helpers! return if helpers_available? endpoint = @env['api.endpoint'] self.class.instance_eval do include endpoint.send(:helpers) end if endpoint.is_a?(Grape::Endpoint) @helpers = true end def helpers_available? @helpers end def error!(message, status = options[:default_status], headers = {}, backtrace = []) headers = headers.reverse_merge(Grape::Http::Headers::CONTENT_TYPE => content_type) rack_response(format_message(message, backtrace), status, headers) end def handle_error(e) error_response(message: e.message, backtrace: e.backtrace) end # TODO: This method is deprecated. Refactor out. def error_response(error = {}) status = error[:status] || options[:default_status] message = error[:message] || options[:default_message] headers = { Grape::Http::Headers::CONTENT_TYPE => content_type } headers.merge!(error[:headers]) if error[:headers].is_a?(Hash) backtrace = error[:backtrace] || [] rack_response(format_message(message, backtrace), status, headers) end def rack_response(message, status = options[:default_status], headers = { Grape::Http::Headers::CONTENT_TYPE => content_type }) Rack::Response.new([message], status, headers).finish end def format_message(message, backtrace) format = env[Grape::Env::API_FORMAT] || options[:format] formatter = Grape::ErrorFormatter.formatter_for(format, options) throw :error, status: 406, message: "The requested format '#{format}' is not supported." unless formatter formatter.call(message, backtrace, options, env) end end end end grape-0.16.2/lib/grape/namespace.rb0000644000004100000410000000227412706307016017062 0ustar www-datawww-datamodule Grape # A container for endpoints or other namespaces, which allows for both # logical grouping of endpoints as well as sharing commonconfiguration. # May also be referred to as group, segment, or resource. class Namespace attr_reader :space, :options # @param space [String] the name of this namespace # @param options [Hash] options hash # @option options :requirements [Hash] param-regex pairs, all of which must # be met by a request's params for all endpoints in this namespace, or # validation will fail and return a 422. def initialize(space, options = {}) @space = space.to_s @options = options end # Retrieves the requirements from the options hash, if given. # @return [Hash] def requirements options[:requirements] || {} end # (see ::joined_space_path) def self.joined_space(settings) (settings || []).map(&:space).join('/') end # Join the namespaces from a list of settings to create a path prefix. # @param settings [Array] list of Grape::Util::InheritableSettings. def self.joined_space_path(settings) Grape::Router.normalize_path(joined_space(settings)) end end end grape-0.16.2/lib/grape/formatter.rb0000644000004100000410000000142412706307016017125 0ustar www-datawww-datamodule Grape module Formatter extend Util::Registrable class << self def builtin_formmaters @builtin_formatters ||= { json: Grape::Formatter::Json, jsonapi: Grape::Formatter::Json, serializable_hash: Grape::Formatter::SerializableHash, txt: Grape::Formatter::Txt, xml: Grape::Formatter::Xml } end def formatters(options) builtin_formmaters.merge(default_elements).merge(options[:formatters] || {}) end def formatter_for(api_format, options = {}) spec = formatters(options)[api_format] case spec when nil ->(obj, _env) { obj } when Symbol method(spec) else spec end end end end end grape-0.16.2/lib/grape/exceptions/0000755000004100000410000000000012706307016016755 5ustar www-datawww-datagrape-0.16.2/lib/grape/exceptions/missing_option.rb0000644000004100000410000000032412706307016022342 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class MissingOption < Base def initialize(option) super(message: compose_message(:missing_option, option: option)) end end end end grape-0.16.2/lib/grape/exceptions/validation.rb0000644000004100000410000000123512706307016021435 0ustar www-datawww-datarequire 'grape/exceptions/base' module Grape module Exceptions class Validation < Grape::Exceptions::Base attr_accessor :params attr_accessor :message_key def initialize(args = {}) fail 'Params are missing:' unless args.key? :params @params = args[:params] args[:message] = translate_message(args[:message]) if args.key? :message super end # remove all the unnecessary stuff from Grape::Exceptions::Base like status # and headers when converting a validation error to json or string def as_json(*_args) to_s end def to_s message end end end end grape-0.16.2/lib/grape/exceptions/missing_group_type.rb0000644000004100000410000000031012706307016023222 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class MissingGroupTypeError < Base def initialize super(message: compose_message(:missing_group_type)) end end end end grape-0.16.2/lib/grape/exceptions/invalid_versioner_option.rb0000644000004100000410000000035512706307016024417 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class InvalidVersionerOption < Base def initialize(strategy) super(message: compose_message(:invalid_versioner_option, strategy: strategy)) end end end end grape-0.16.2/lib/grape/exceptions/missing_vendor_option.rb0000644000004100000410000000031112706307016023713 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class MissingVendorOption < Base def initialize super(message: compose_message(:missing_vendor_option)) end end end end grape-0.16.2/lib/grape/exceptions/incompatible_option_values.rb0000644000004100000410000000047112706307016024721 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class IncompatibleOptionValues < Base def initialize(option1, value1, option2, value2) super(message: compose_message(:incompatible_option_values, option1: option1, value1: value1, option2: option2, value2: value2)) end end end end grape-0.16.2/lib/grape/exceptions/validation_errors.rb0000644000004100000410000000251212706307016023030 0ustar www-datawww-datarequire 'grape/exceptions/base' module Grape module Exceptions class ValidationErrors < Grape::Exceptions::Base include Enumerable attr_reader :errors def initialize(args = {}) @errors = {} args[:errors].each do |validation_error| @errors[validation_error.params] ||= [] @errors[validation_error.params] << validation_error end super message: full_messages.join(', '), status: 400, headers: args[:headers] end def each errors.each_pair do |attribute, errors| errors.each do |error| yield attribute, error end end end def as_json(_opts = {}) errors.map do |k, v| { params: k, messages: v.map(&:to_s) } end end def to_json(_opts = {}) as_json.to_json end def full_messages map { |attributes, error| full_message(attributes, error) }.uniq end private def full_message(attributes, error) I18n.t( 'grape.errors.format'.to_sym, default: '%{attributes} %{message}', attributes: attributes.count == 1 ? translate_attribute(attributes.first) : translate_attributes(attributes), message: error.message ) end end end end grape-0.16.2/lib/grape/exceptions/invalid_with_option_for_represent.rb0000644000004100000410000000033712706307016026313 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class InvalidWithOptionForRepresent < Base def initialize super(message: compose_message(:invalid_with_option_for_represent)) end end end end grape-0.16.2/lib/grape/exceptions/invalid_accept_header.rb0000644000004100000410000000041412706307016023556 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class InvalidAcceptHeader < Base def initialize(message, headers) super(message: compose_message(:invalid_accept_header, message: message), status: 406, headers: headers) end end end end grape-0.16.2/lib/grape/exceptions/unknown_parameter.rb0000644000004100000410000000032712706307016023043 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class UnknownParameter < Base def initialize(param) super(message: compose_message(:unknown_parameter, param: param)) end end end end grape-0.16.2/lib/grape/exceptions/unknown_options.rb0000644000004100000410000000033112706307016022551 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class UnknownOptions < Base def initialize(options) super(message: compose_message(:unknown_options, options: options)) end end end end grape-0.16.2/lib/grape/exceptions/invalid_version_header.rb0000644000004100000410000000041612706307016024006 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class InvalidVersionHeader < Base def initialize(message, headers) super(message: compose_message(:invalid_version_header, message: message), status: 406, headers: headers) end end end end grape-0.16.2/lib/grape/exceptions/invalid_formatter.rb0000644000004100000410000000037012706307016023013 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class InvalidFormatter < Base def initialize(klass, to_format) super(message: compose_message(:invalid_formatter, klass: klass, to_format: to_format)) end end end end grape-0.16.2/lib/grape/exceptions/method_not_allowed.rb0000644000004100000410000000033012706307016023145 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class MethodNotAllowed < Base def initialize(headers) super(message: '405 Not Allowed', status: 405, headers: headers) end end end end grape-0.16.2/lib/grape/exceptions/unknown_validator.rb0000644000004100000410000000036212706307016023047 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class UnknownValidator < Base def initialize(validator_type) super(message: compose_message(:unknown_validator, validator_type: validator_type)) end end end end grape-0.16.2/lib/grape/exceptions/invalid_message_body.rb0000644000004100000410000000037312706307016023454 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class InvalidMessageBody < Base def initialize(body_format) super(message: compose_message(:invalid_message_body, body_format: body_format), status: 400) end end end end grape-0.16.2/lib/grape/exceptions/base.rb0000644000004100000410000000467012706307016020223 0ustar www-datawww-datamodule Grape module Exceptions class Base < StandardError BASE_MESSAGES_KEY = 'grape.errors.messages'.freeze BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'.freeze FALLBACK_LOCALE = :en attr_reader :status, :message, :headers def initialize(args = {}) @status = args[:status] || nil @message = args[:message] || nil @headers = args[:headers] || nil end def [](index) send index end protected # TODO: translate attribute first # if BASE_ATTRIBUTES_KEY.key respond to a string message, then short_message is returned # if BASE_ATTRIBUTES_KEY.key respond to a Hash, means it may have problem , summary and resolution def compose_message(key, attributes = {}) short_message = translate_message(key, attributes) if short_message.is_a? Hash @problem = problem(key, attributes) @summary = summary(key, attributes) @resolution = resolution(key, attributes) [['Problem', @problem], ['Summary', @summary], ['Resolution', @resolution]].reduce('') do |message, detail_array| message << "\n#{detail_array[0]}:\n #{detail_array[1]}" unless detail_array[1].blank? message end else short_message end end def problem(key, attributes) translate_message("#{key}.problem".to_sym, attributes) end def summary(key, attributes) translate_message("#{key}.summary".to_sym, attributes) end def resolution(key, attributes) translate_message("#{key}.resolution".to_sym, attributes) end def translate_attributes(keys, options = {}) keys.map do |key| translate("#{BASE_ATTRIBUTES_KEY}.#{key}", options.reverse_merge(default: key)) end.join(', ') end def translate_attribute(key, options = {}) translate("#{BASE_ATTRIBUTES_KEY}.#{key}", options.reverse_merge(default: key)) end def translate_message(key, options = {}) case key when Symbol translate("#{BASE_MESSAGES_KEY}.#{key}", options.reverse_merge(default: '')) when Proc key.call else key end end def translate(key, options = {}) message = ::I18n.translate(key, options) message.present? ? message : ::I18n.translate(key, options.merge(locale: FALLBACK_LOCALE)) end end end end grape-0.16.2/lib/grape/exceptions/missing_mime_type.rb0000644000004100000410000000034512706307016023025 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class MissingMimeType < Base def initialize(new_format) super(message: compose_message(:missing_mime_type, new_format: new_format)) end end end end grape-0.16.2/lib/grape/exceptions/unsupported_group_type.rb0000644000004100000410000000032012706307016024142 0ustar www-datawww-data# encoding: utf-8 module Grape module Exceptions class UnsupportedGroupTypeError < Base def initialize super(message: compose_message(:unsupported_group_type)) end end end end grape-0.16.2/lib/grape/router.rb0000644000004100000410000001065112706307016016444 0ustar www-datawww-datarequire 'grape/router/route' module Grape class Router attr_reader :map, :compiled class Any < AttributeTranslator def initialize(pattern, attributes = {}) @pattern = pattern super(attributes) end end def initialize @neutral_map = [] @map = Hash.new { |hash, key| hash[key] = [] } @optimized_map = Hash.new { |hash, key| hash[key] = // } end def compile! return if compiled @union = Regexp.union(@neutral_map.map(&:regexp)) map.each do |method, routes| @optimized_map[method] = routes.map.with_index do |route, index| route.index = index route.regexp = /(?<_#{index}>#{route.pattern.to_regexp})/ end @optimized_map[method] = Regexp.union(@optimized_map[method]) end @compiled = true end def append(route) map[route.request_method.to_s.upcase] << route end def associate_routes(pattern, options = {}) regexp = /(?<_#{@neutral_map.length}>)#{pattern.to_regexp}/ @neutral_map << Any.new(pattern, options.merge(regexp: regexp, index: @neutral_map.length)) end def call(env) with_optimization do response, route = identity(env) response || rotation(env, route) end end def recognize_path(input) any = with_optimization { greedy_match?(input) } return if any == default_response any.endpoint end private def identity(env) route = nil response = transaction(env) do |input, method, routing_args| route = match?(input, method) if route env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input) route.exec(env) end end [response, route] end def rotation(env, exact_route = nil) response = nil input, method, routing_args = *extract_required_args(env) routes_for(method).each do |route| next if exact_route == route next unless route.match?(input) env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input) response = route.exec(env) break unless cascade?(response) end response end def transaction(env) input, method, routing_args = *extract_required_args(env) response = yield(input, method, routing_args) return response if response && !(cascade = cascade?(response)) neighbor = greedy_match?(input) return unless neighbor (!cascade && neighbor) ? method_not_allowed(env, neighbor.allow_header, neighbor.endpoint) : nil end def make_routing_args(default_args, route, input) args = default_args || { route_info: route } args.merge(route.params(input)) end def extract_required_args(env) input = string_for(env[Grape::Http::Headers::PATH_INFO]) method = env[Grape::Http::Headers::REQUEST_METHOD] routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS] [input, method, routing_args] end def with_optimization compile! unless compiled yield || default_response end def default_response [404, { Grape::Http::Headers::X_CASCADE => 'pass' }, ['404 Not Found']] end def match?(input, method) current_regexp = @optimized_map[method] return unless current_regexp.match(input) last_match = Regexp.last_match @map[method].detect { |route| last_match["_#{route.index}"] } end def greedy_match?(input) return unless @union.match(input) last_match = Regexp.last_match @neutral_map.detect { |route| last_match["_#{route.index}"] } end def method_not_allowed(env, methods, endpoint) env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED] = true current = endpoint.dup current.instance_eval do @lazy_initialized = false lazy_initialize! run_filters befores, :before @block = proc do fail Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => methods) end end current.call(env) end def cascade?(response) response && response[1][Grape::Http::Headers::X_CASCADE] == 'pass' end def routes_for(method) map[method] + map['ANY'] end def string_for(input) self.class.normalize_path(input) end def self.normalize_path(path) path = "/#{path}" path.squeeze!('/') path.sub!(%r{/+\Z}, '') path = '/' if path == '' path end end end grape-0.16.2/lib/grape/formatter/0000755000004100000410000000000012706307016016577 5ustar www-datawww-datagrape-0.16.2/lib/grape/formatter/xml.rb0000644000004100000410000000042412706307016017724 0ustar www-datawww-datamodule Grape module Formatter module Xml class << self def call(object, _env) return object.to_xml if object.respond_to?(:to_xml) fail Grape::Exceptions::InvalidFormatter.new(object.class, 'xml') end end end end end grape-0.16.2/lib/grape/formatter/json.rb0000644000004100000410000000035412706307016020077 0ustar www-datawww-datamodule Grape module Formatter module Json class << self def call(object, _env) return object.to_json if object.respond_to?(:to_json) MultiJson.dump(object) end end end end end grape-0.16.2/lib/grape/formatter/serializable_hash.rb0000644000004100000410000000210212706307016022570 0ustar www-datawww-datamodule Grape module Formatter module SerializableHash class << self def call(object, _env) return object if object.is_a?(String) return MultiJson.dump(serialize(object)) if serializable?(object) return object.to_json if object.respond_to?(:to_json) MultiJson.dump(object) end private def serializable?(object) object.respond_to?(:serializable_hash) || object.is_a?(Array) && !object.map { |o| o.respond_to? :serializable_hash }.include?(false) || object.is_a?(Hash) end def serialize(object) if object.respond_to? :serializable_hash object.serializable_hash elsif object.is_a?(Array) && !object.map { |o| o.respond_to? :serializable_hash }.include?(false) object.map(&:serializable_hash) elsif object.is_a?(Hash) h = {} object.each_pair do |k, v| h[k] = serialize(v) end h else object end end end end end end grape-0.16.2/lib/grape/formatter/txt.rb0000644000004100000410000000031612706307016017743 0ustar www-datawww-datamodule Grape module Formatter module Txt class << self def call(object, _env) object.respond_to?(:to_txt) ? object.to_txt : object.to_s end end end end end grape-0.16.2/lib/grape/parser.rb0000644000004100000410000000117212706307016016416 0ustar www-datawww-datamodule Grape module Parser extend Util::Registrable class << self def builtin_parsers @builtin_parsers ||= { json: Grape::Parser::Json, jsonapi: Grape::Parser::Json, xml: Grape::Parser::Xml } end def parsers(options) builtin_parsers.merge(default_elements).merge(options[:parsers] || {}) end def parser_for(api_format, options = {}) spec = parsers(options)[api_format] case spec when nil nil when Symbol method(spec) else spec end end end end end grape-0.16.2/lib/grape/path.rb0000644000004100000410000000314212706307016016055 0ustar www-datawww-datamodule Grape # Represents a path to an endpoint. class Path def self.prepare(raw_path, namespace, settings) Path.new(raw_path, namespace, settings) end attr_reader :raw_path, :namespace, :settings def initialize(raw_path, namespace, settings) @raw_path = raw_path @namespace = namespace @settings = settings end def mount_path settings[:mount_path] end def root_prefix split_setting(:root_prefix) end def uses_specific_format? !!(settings[:format] && Array(settings[:content_types]).size == 1) end def uses_path_versioning? !!(settings[:version] && settings[:version_options][:using] == :path) end def namespace? namespace && namespace.to_s =~ /^\S/ && namespace != '/' end def path? raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/' end def suffix if uses_specific_format? "(.#{settings[:format]})" elsif !uses_path_versioning? || (namespace? || path?) '(.:format)' else '(/.:format)' end end def path Grape::Router.normalize_path(parts.join('/')) end def path_with_suffix "#{path}#{suffix}" end def to_s path_with_suffix end private def parts parts = [mount_path, root_prefix].compact parts << ':version' if uses_path_versioning? parts << namespace.to_s parts << raw_path.to_s parts.flatten.reject { |part| part == '/' } end def split_setting(key) return if settings[key].nil? settings[key].to_s.split('/') end end end grape-0.16.2/lib/grape/parser/0000755000004100000410000000000012706307016016070 5ustar www-datawww-datagrape-0.16.2/lib/grape/parser/xml.rb0000644000004100000410000000055412706307016017221 0ustar www-datawww-datamodule Grape module Parser module Xml class << self def call(object, _env) MultiXml.parse(object) rescue MultiXml::ParseError # handle XML parsing errors via the rescue handlers or provide error message raise Grape::Exceptions::InvalidMessageBody, 'application/xml' end end end end end grape-0.16.2/lib/grape/parser/json.rb0000644000004100000410000000056012706307016017367 0ustar www-datawww-datamodule Grape module Parser module Json class << self def call(object, _env) MultiJson.load(object) rescue MultiJson::ParseError # handle JSON parsing errors via the rescue handlers or provide error message raise Grape::Exceptions::InvalidMessageBody, 'application/json' end end end end end grape-0.16.2/lib/grape/api/0000755000004100000410000000000012706307016015345 5ustar www-datawww-datagrape-0.16.2/lib/grape/api/helpers.rb0000644000004100000410000000015412706307016017334 0ustar www-datawww-datamodule Grape class API module Helpers include Grape::DSL::Helpers::BaseHelper end end end grape-0.16.2/lib/grape/request.rb0000644000004100000410000000151512706307016016613 0ustar www-datawww-datamodule Grape class Request < Rack::Request HTTP_PREFIX = 'HTTP_'.freeze alias_method :rack_params, :params def params @params ||= build_params end def headers @headers ||= build_headers end private def build_params params = Hashie::Mash.new(rack_params) if env[Grape::Env::GRAPE_ROUTING_ARGS] args = env[Grape::Env::GRAPE_ROUTING_ARGS].dup # preserve version from query string parameters args.delete(:version) args.delete(:route_info) params.deep_merge!(args) end params end def build_headers headers = {} env.each_pair do |k, v| next unless k.to_s.start_with? HTTP_PREFIX k = k[5..-1].split('_').each(&:capitalize!).join('-') headers[k] = v end headers end end end grape-0.16.2/lib/grape/api.rb0000644000004100000410000002023012706307016015667 0ustar www-datawww-datarequire 'grape/router' module Grape # The API class is the primary entry point for creating Grape APIs. Users # should subclass this class in order to build an API. class API include Grape::DSL::API class << self attr_reader :instance # A class-level lock to ensure the API is not compiled by multiple # threads simultaneously within the same process. LOCK = Mutex.new # Clears all defined routes, endpoints, etc., on this API. def reset! reset_endpoints! reset_routes! reset_validations! end # Parses the API's definition and compiles it into an instance of # Grape::API. def compile @instance ||= new end # Wipe the compiled API so we can recompile after changes were made. def change! @instance = nil end # This is the interface point between Rack and Grape; it accepts a request # from Rack and ultimately returns an array of three values: the status, # the headers, and the body. See [the rack specification] # (http://www.rubydoc.info/github/rack/rack/master/file/SPEC) for more. def call(env) LOCK.synchronize { compile } unless instance call!(env) end # A non-synchronized version of ::call. def call!(env) instance.call(env) end # (see #cascade?) def cascade(value = nil) if value.nil? inheritable_setting.namespace_inheritable.keys.include?(:cascade) ? !namespace_inheritable(:cascade).nil? : true else namespace_inheritable(:cascade, value) end end # see Grape::Router#recognize_path def recognize_path(path) LOCK.synchronize { compile } unless instance instance.router.recognize_path(path) end protected def prepare_routes endpoints.map(&:routes).flatten end # Execute first the provided block, then each of the # block passed in. Allows for simple 'before' setups # of settings stack pushes. def nest(*blocks, &block) blocks.reject!(&:nil?) if blocks.any? instance_eval(&block) if block_given? blocks.each { |b| instance_eval(&b) } reset_validations! else instance_eval(&block) end end def inherited(subclass) subclass.reset! subclass.logger = logger.clone end def inherit_settings(other_settings) top_level_setting.inherit_from other_settings.point_in_time_copy reset_routes! end end attr_reader :router # Builds the routes from the defined endpoints, effectively compiling # this API into a usable form. def initialize @router = Router.new add_head_not_allowed_methods_and_options_methods self.class.endpoints.each do |endpoint| endpoint.mount_in(@router) end @router.compile! @router.freeze end # Handle a request. See Rack documentation for what `env` is. def call(env) result = @router.call(env) result[1].delete(Grape::Http::Headers::X_CASCADE) unless cascade? result end # Some requests may return a HTTP 404 error if grape cannot find a matching # route. In this case, Grape::Router adds a X-Cascade header to the response # and sets it to 'pass', indicating to grape's parents they should keep # looking for a matching route on other resources. # # In some applications (e.g. mounting grape on rails), one might need to trap # errors from reaching upstream. This is effectivelly done by unsetting # X-Cascade. Default :cascade is true. def cascade? return !!self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.keys.include?(:cascade) return !!self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options) && self.class.namespace_inheritable(:version_options).key?(:cascade) true end reset! private # For every resource add a 'OPTIONS' route that returns an HTTP 204 response # with a list of HTTP methods that can be called. Also add a route that # will return an HTTP 405 response for any HTTP method that the resource # cannot handle. def add_head_not_allowed_methods_and_options_methods routes_map = {} self.class.endpoints.each do |endpoint| routes = endpoint.routes routes.each do |route| # using the :any shorthand produces [nil] for route methods, substitute all manually route_key = route.pattern.to_regexp routes_map[route_key] ||= {} route_settings = routes_map[route_key] route_settings[:pattern] = route.pattern route_settings[:requirements] = route.requirements route_settings[:path] = route.origin route_settings[:methods] ||= [] route_settings[:methods] << route.request_method route_settings[:endpoint] = route.app # using the :any shorthand produces [nil] for route methods, substitute all manually route_settings[:methods] = %w(GET PUT POST DELETE PATCH HEAD OPTIONS) if route_settings[:methods].include?('ANY') end end # The paths we collected are prepared (cf. Path#prepare), so they # contain already versioning information when using path versioning. # Disable versioning so adding a route won't prepend versioning # informations again. without_root_prefix do without_versioning do routes_map.each do |_, config| methods = config[:methods] path = config[:path] allowed_methods = methods.dup unless self.class.namespace_inheritable(:do_not_route_head) allowed_methods |= [Grape::Http::Headers::HEAD] if allowed_methods.include?(Grape::Http::Headers::GET) end allow_header = (self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Grape::Http::Headers::OPTIONS] | allowed_methods).join(', ') unless self.class.namespace_inheritable(:do_not_route_options) generate_options_method(path, allow_header, config) unless allowed_methods.include?(Grape::Http::Headers::OPTIONS) end attributes = config.merge(allowed_methods: allowed_methods, allow_header: allow_header) generate_not_allowed_method(config[:pattern], attributes) end end end end # Generate an 'OPTIONS' route for a pre-exisiting user defined route def generate_options_method(path, allow_header, options = {}) self.class.options(path, options) do header 'Allow', allow_header status 204 '' end end # Generate a route that returns an HTTP 405 response for a user defined # path on methods not specified def generate_not_allowed_method(pattern, attributes = {}) not_allowed_methods = %w(GET PUT POST DELETE PATCH HEAD) - attributes[:allowed_methods] not_allowed_methods << Grape::Http::Headers::OPTIONS if self.class.namespace_inheritable(:do_not_route_options) return if not_allowed_methods.empty? @router.associate_routes(pattern, attributes.merge(not_allowed_methods: not_allowed_methods)) end # Allows definition of endpoints that ignore the versioning configuration # used by the rest of your API. def without_versioning(&_block) old_version = self.class.namespace_inheritable(:version) old_version_options = self.class.namespace_inheritable(:version_options) self.class.namespace_inheritable_to_nil(:version) self.class.namespace_inheritable_to_nil(:version_options) yield self.class.namespace_inheritable(:version, old_version) self.class.namespace_inheritable(:version_options, old_version_options) end # Allows definition of endpoints that ignore the root prefix used by the # rest of your API. def without_root_prefix(&_block) old_prefix = self.class.namespace_inheritable(:root_prefix) self.class.namespace_inheritable_to_nil(:root_prefix) yield self.class.namespace_inheritable(:root_prefix, old_prefix) end end end grape-0.16.2/lib/grape/endpoint.rb0000644000004100000410000002646612706307016016757 0ustar www-datawww-datamodule Grape # An Endpoint is the proxy scope in which all routing # blocks are executed. In other words, any methods # on the instance level of this class may be called # from inside a `get`, `post`, etc. class Endpoint include Grape::DSL::Settings include Grape::DSL::InsideRoute attr_accessor :block, :source, :options attr_reader :env, :request, :headers, :params class << self def new(*args, &block) if self == Endpoint Class.new(Endpoint).new(*args, &block) else super end end def before_each(new_setup = false, &block) @before_each ||= [] if new_setup == false if block_given? @before_each << block else return @before_each end else @before_each = [new_setup] end end def run_before_each(endpoint) superclass.run_before_each(endpoint) unless self == Endpoint before_each.each do |blk| blk.call(endpoint) if blk.respond_to? :call end end # @api private # # Create an UnboundMethod that is appropriate for executing an endpoint # route. # # The unbound method allows explicit calls to +return+ without raising a # +LocalJumpError+. The method will be removed, but a +Proc+ reference to # it will be returned. The returned +Proc+ expects a single argument: the # instance of +Endpoint+ to bind to the method during the call. # # @param [String, Symbol] method_name # @return [Proc] # @raise [NameError] an instance method with the same name already exists def generate_api_method(method_name, &block) if instance_methods.include?(method_name.to_sym) || instance_methods.include?(method_name.to_s) fail NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name") end define_method(method_name, &block) method = instance_method(method_name) remove_method(method_name) proc do |endpoint_instance| ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do method.bind(endpoint_instance).call end end end end def initialize(new_settings, options = {}, &block) require_option(options, :path) require_option(options, :method) self.inheritable_setting = new_settings.point_in_time_copy route_setting(:saved_declared_params, namespace_stackable(:declared_params)) route_setting(:saved_validations, namespace_stackable(:validations)) namespace_stackable(:representations, []) unless namespace_stackable(:representations) namespace_inheritable(:default_error_status, 500) unless namespace_inheritable(:default_error_status) @options = options @options[:path] = Array(options[:path]) @options[:path] << '/' if options[:path].empty? @options[:method] = Array(options[:method]) @options[:route_options] ||= {} @lazy_initialize_lock = Mutex.new return unless block_given? @source = block @block = self.class.generate_api_method(method_name, &block) end def require_option(options, key) fail Grape::Exceptions::MissingOption.new(key) unless options.key?(key) end def method_name [options[:method], Namespace.joined_space(namespace_stackable(:namespace)), (namespace_stackable(:mount_path) || []).join('/'), options[:path].join('/') ].join(' ') end def routes @routes ||= endpoints ? endpoints.collect(&:routes).flatten : to_routes end def reset_routes! endpoints.each(&:reset_routes!) if endpoints @namespace = nil @routes = nil end def mount_in(router) if endpoints endpoints.each { |e| e.mount_in(router) } else reset_routes! routes.each do |route| methods = [route.request_method] if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET methods << Grape::Http::Headers::HEAD end methods.each do |method| unless route.request_method.to_s.upcase == method route = Grape::Router::Route.new(method, route.origin, route.attributes.to_h) end router.append(route.apply(self)) end end end end def to_routes route_options = prepare_default_route_attributes map_routes do |method, path| path = prepare_path(path) params = merge_route_options(route_options.merge(suffix: path.suffix)) route = Router::Route.new(method, path.path, params) route.apply(self) end.flatten end def prepare_routes_requirements endpoint_requirements = options[:route_options][:requirements] || {} all_requirements = (namespace_stackable(:namespace).map(&:requirements) << endpoint_requirements) all_requirements.reduce({}) do |base_requirements, single_requirements| base_requirements.merge!(single_requirements) end end def prepare_default_route_attributes { namespace: namespace, version: prepare_version, requirements: prepare_routes_requirements, prefix: namespace_inheritable(:root_prefix), anchor: options[:route_options].fetch(:anchor, true), settings: inheritable_setting.route.except(:saved_declared_params, :saved_validations), forward_match: options[:forward_match] } end def prepare_version version = namespace_inheritable(:version) || [] return if version.length == 0 version.length == 1 ? version.first.to_s : version end def merge_route_options(default = {}) options[:route_options].clone.reverse_merge(default) end def map_routes options[:method].map { |method| options[:path].map { |path| yield method, path } } end def prepare_path(path) path_settings = inheritable_setting.to_hash[:namespace_stackable].merge(inheritable_setting.to_hash[:namespace_inheritable]) Path.prepare(path, namespace, path_settings) end def namespace @namespace ||= Namespace.joined_space_path(namespace_stackable(:namespace)) end def call(env) lazy_initialize! dup.call!(env) end def call!(env) env[Grape::Env::API_ENDPOINT] = self @env = env @app.call(env) end # Return the collection of endpoints within this endpoint. # This is the case when an Grape::API mounts another Grape::API. def endpoints options[:app].endpoints if options[:app] && options[:app].respond_to?(:endpoints) end def equals?(e) (options == e.options) && (inheritable_setting.to_hash == e.inheritable_setting.to_hash) end protected def run ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do @header = {} @request = Grape::Request.new(env) @params = @request.params @headers = @request.headers cookies.read(@request) self.class.run_before_each(self) run_filters befores, :before run_filters before_validations, :before_validation run_validators validations, request unless env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED] run_filters after_validations, :after_validation response_object = @block ? @block.call(self) : nil run_filters afters, :after cookies.write(header) # The Body commonly is an Array of Strings, the application instance itself, or a File-like object. response_object = file || [body || response_object] [status, header, response_object] end end def build_stack b = Rack::Builder.new b.use Rack::Head b.use Grape::Middleware::Error, format: namespace_inheritable(:format), content_types: namespace_stackable_with_hash(:content_types), default_status: namespace_inheritable(:default_error_status), rescue_all: namespace_inheritable(:rescue_all), default_error_formatter: namespace_inheritable(:default_error_formatter), error_formatters: namespace_stackable_with_hash(:error_formatters), rescue_options: namespace_stackable_with_hash(:rescue_options) || {}, rescue_handlers: namespace_stackable_with_hash(:rescue_handlers) || {}, base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {}, all_rescue_handler: namespace_inheritable(:all_rescue_handler) (namespace_stackable(:middleware) || []).each do |m| m = m.dup block = m.pop if m.last.is_a?(Proc) block ? b.use(*m, &block) : b.use(*m) end if namespace_inheritable(:version) b.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]), versions: namespace_inheritable(:version) ? namespace_inheritable(:version).flatten : nil, version_options: namespace_inheritable(:version_options), prefix: namespace_inheritable(:root_prefix) end b.use Grape::Middleware::Formatter, format: namespace_inheritable(:format), default_format: namespace_inheritable(:default_format) || :txt, content_types: namespace_stackable_with_hash(:content_types), formatters: namespace_stackable_with_hash(:formatters), parsers: namespace_stackable_with_hash(:parsers) b.run ->(env) { env[Grape::Env::API_ENDPOINT].run } b.to_app end def build_helpers helpers = namespace_stackable(:helpers) || [] Module.new do helpers.each { |mod_to_include| include mod_to_include } end end private :build_stack, :build_helpers def helpers lazy_initialize! && @helpers end def lazy_initialize! return true if @lazy_initialized @lazy_initialize_lock.synchronize do return true if @lazy_initialized @app = options[:app] || build_stack @helpers = build_helpers.tap do |mod| self.class.send(:include, mod) end @lazy_initialized = true end end def run_validators(validators, request) validation_errors = [] validators.each do |validator| begin validator.validate(request) rescue Grape::Exceptions::Validation => e validation_errors << e end end validation_errors.any? && fail(Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header) end def run_filters(filters, type = :other) ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do (filters || []).each { |filter| instance_eval(&filter) } end post_extension = DSL::InsideRoute.post_filter_methods(type) extend post_extension if post_extension end def befores namespace_stackable(:befores) || [] end def before_validations namespace_stackable(:before_validations) || [] end def after_validations namespace_stackable(:after_validations) || [] end def afters namespace_stackable(:afters) || [] end def validations route_setting(:saved_validations) || [] end end end grape-0.16.2/lib/grape/version.rb0000644000004100000410000000011012706307016016576 0ustar www-datawww-datamodule Grape # The current version of Grape. VERSION = '0.16.2' end grape-0.16.2/lib/grape/validations/0000755000004100000410000000000012706307016017111 5ustar www-datawww-datagrape-0.16.2/lib/grape/validations/params_scope.rb0000644000004100000410000003420512706307016022116 0ustar www-datawww-datamodule Grape module Validations class ParamsScope attr_accessor :element, :parent, :index include Grape::DSL::Parameters # Open up a new ParamsScope, allowing parameter definitions per # Grape::DSL::Params. # @param opts [Hash] options for this scope # @option opts :element [Symbol] the element that contains this scope; for # this to be relevant, @parent must be set # @option opts :parent [ParamsScope] the scope containing this scope # @option opts :api [API] the API endpoint to modify # @option opts :optional [Boolean] whether or not this scope needs to have # any parameters set or not # @option opts :type [Class] a type meant to govern this scope (deprecated) # @option opts :dependent_on [Symbol] if present, this scope should only # validate if this param is present in the parent scope # @yield the instance context, open for parameter definitions def initialize(opts, &block) @element = opts[:element] @parent = opts[:parent] @api = opts[:api] @optional = opts[:optional] || false @type = opts[:type] @dependent_on = opts[:dependent_on] @declared_params = [] instance_eval(&block) if block_given? configure_declared_params end # @return [Boolean] whether or not this entire scope needs to be # validated def should_validate?(parameters) return false if @optional && params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?) @dependent_on.each do |dependency| return false if params(parameters).try(:[], dependency).blank? end if @dependent_on return true if parent.nil? parent.should_validate?(parameters) end # @return [String] the proper attribute name, with nesting considered. def full_name(name) case when nested? # Find our containing element's name, and append ours. "#{@parent.full_name(@element)}#{parent_index}[#{name}]" when lateral? # Find the name of the element as if it was at the # same nesting level as our parent. @parent.full_name(name) else # We must be the root scope, so no prefix needed. name.to_s end end def parent_index "[#{@parent.index}]" if @parent.present? && @parent.index.present? end # @return [Boolean] whether or not this scope is the root-level scope def root? !@parent end # A nested scope is contained in one of its parent's elements. # @return [Boolean] whether or not this scope is nested def nested? @parent && @element end # A lateral scope is subordinate to its parent, but its keys are at the # same level as its parent and thus is not contained within an element. # @return [Boolean] whether or not this scope is lateral def lateral? @parent && !@element end # @return [Boolean] whether or not this scope needs to be present, or can # be blank def required? !@optional end protected # Adds a parameter declaration to our list of validations. # @param attrs [Array] (see Grape::DSL::Parameters#requires) def push_declared_params(attrs) if lateral? @parent.push_declared_params(attrs) else @declared_params.concat attrs end end private def require_required_and_optional_fields(context, opts) if context == :all optional_fields = Array(opts[:except]) required_fields = opts[:using].keys - optional_fields else # context == :none required_fields = Array(opts[:except]) optional_fields = opts[:using].keys - required_fields end required_fields.each do |field| field_opts = opts[:using][field] fail ArgumentError, "required field not exist: #{field}" unless field_opts requires(field, field_opts) end optional_fields.each do |field| field_opts = opts[:using][field] optional(field, field_opts) if field_opts end end def require_optional_fields(context, opts) optional_fields = opts[:using].keys optional_fields -= Array(opts[:except]) unless context == :all optional_fields.each do |field| field_opts = opts[:using][field] optional(field, field_opts) if field_opts end end def validate_attributes(attrs, opts, &block) validations = opts.clone validations[:type] ||= Array if block validates(attrs, validations) end # Returns a new parameter scope, subordinate to the current one and nested # under the parameter corresponding to `attrs.first`. # @param attrs [Array] the attributes passed to the `requires` or # `optional` invocation that opened this scope. # @param optional [Boolean] whether the parameter this are nested under # is optional or not (and hence, whether this block's params will be). # @yield parameter scope def new_scope(attrs, optional = false, &block) # if required params are grouped and no type or unsupported type is provided, raise an error type = attrs[1] ? attrs[1][:type] : nil if attrs.first && !optional fail Grape::Exceptions::MissingGroupTypeError.new if type.nil? fail Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type) end opts = attrs[1] || { type: Array } self.class.new( api: @api, element: attrs.first, parent: self, optional: optional, type: opts[:type], &block) end # Returns a new parameter scope, not nested under any current-level param # but instead at the same level as the current scope. # @param options [Hash] options to control how this new scope behaves # @option options :dependent_on [Symbol] if given, specifies that this # scope should only validate if this parameter from the above scope is # present # @yield parameter scope def new_lateral_scope(options, &block) self.class.new( api: @api, element: nil, parent: self, options: @optional, type: Hash, dependent_on: options[:dependent_on], &block) end # Pushes declared params to parent or settings def configure_declared_params if nested? @parent.push_declared_params [element => @declared_params] else @api.namespace_stackable(:declared_params, @declared_params) @api.route_setting(:declared_params, []) unless @api.route_setting(:declared_params) @api.route_setting(:declared_params).concat @declared_params end end def validates(attrs, validations) doc_attrs = { required: validations.keys.include?(:presence) } coerce_type = infer_coercion(validations) doc_attrs[:type] = coerce_type.to_s if coerce_type desc = validations.delete(:desc) || validations.delete(:description) doc_attrs[:desc] = desc if desc default = validations[:default] doc_attrs[:default] = default if validations.key?(:default) values = (options_key?(:values, :value, validations)) ? validations[:values][:value] : validations[:values] doc_attrs[:values] = values if values coerce_type = guess_coerce_type(coerce_type, values) # default value should be present in values array, if both exist and are not procs check_incompatible_option_values(values, default) # type should be compatible with values array, if both exist validate_value_coercion(coerce_type, values) doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation) full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } } @api.document_attribute(full_attrs, doc_attrs) # Validate for presence before any other validators if validations.key?(:presence) && validations[:presence] validate('presence', validations[:presence], attrs, doc_attrs) validations.delete(:presence) validations.delete(:message) if validations.key?(:message) end # Before we run the rest of the validators, let's handle # whatever coercion so that we are working with correctly # type casted values coerce_type validations, attrs, doc_attrs validations.each do |type, options| validate(type, options, attrs, doc_attrs) end end # Validate and comprehend the +:type+, +:types+, and +:coerce_with+ # options that have been supplied to the parameter declaration. # The +:type+ and +:types+ options will be removed from the # validations list, replaced appropriately with +:coerce+ and # +:coerce_with+ options that will later be passed to # {Validators::CoerceValidator}. The type that is returned may be # used for documentation and further validation of parameter # options. # # @param validations [Hash] list of validations supplied to the # parameter declaration # @return [class-like] type to which the parameter will be coerced # @raise [ArgumentError] if the given type options are invalid def infer_coercion(validations) if validations.key?(:type) && validations.key?(:types) fail ArgumentError, ':type may not be supplied with :types' end validations[:coerce] = (options_key?(:type, :value, validations) ? validations[:type][:value] : validations[:type]) if validations.key?(:type) validations[:coerce_message] = (options_key?(:type, :message, validations) ? validations[:type][:message] : nil) if validations.key?(:type) validations[:coerce] = (options_key?(:types, :value, validations) ? validations[:types][:value] : validations[:types]) if validations.key?(:types) validations[:coerce_message] = (options_key?(:types, :message, validations) ? validations[:types][:message] : nil) if validations.key?(:types) validations.delete(:types) if validations.key?(:types) coerce_type = validations[:coerce] # Special case - when the argument is a single type that is a # variant-type collection. if Types.multiple?(coerce_type) && validations.key?(:type) validations[:coerce] = Types::VariantCollectionCoercer.new( coerce_type, validations.delete(:coerce_with) ) end validations.delete(:type) coerce_type end # Enforce correct usage of :coerce_with parameter. # We do not allow coercion without a type, nor with # +JSON+ as a type since this defines its own coercion # method. def check_coerce_with(validations) return unless validations.key?(:coerce_with) # type must be supplied for coerce_with.. fail ArgumentError, 'must supply type for coerce_with' unless validations.key?(:coerce) # but not special JSON types, which # already imply coercion method return unless [JSON, Array[JSON]].include? validations[:coerce] fail ArgumentError, 'coerce_with disallowed for type: JSON' end # Add type coercion validation to this scope, # if any has been specified. # This validation has special handling since it is # composited from more than one +requires+/+optional+ # parameter, and needs to be run before most other # validations. def coerce_type(validations, attrs, doc_attrs) check_coerce_with(validations) return unless validations.key?(:coerce) coerce_options = { type: validations[:coerce], method: validations[:coerce_with], message: validations[:coerce_message] } validate('coerce', coerce_options, attrs, doc_attrs) validations.delete(:coerce_with) validations.delete(:coerce) validations.delete(:coerce_message) end def guess_coerce_type(coerce_type, values) return coerce_type if !values || values.is_a?(Proc) return values.first.class if coerce_type == Array && (values.is_a?(Range) || !values.empty?) coerce_type end def check_incompatible_option_values(values, default) return unless values && default return if values.is_a?(Proc) || default.is_a?(Proc) return if values.include?(default) || (Array(default) - Array(values)).empty? fail Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) end def validate(type, options, attrs, doc_attrs) validator_class = Validations.validators[type.to_s] if validator_class value = validator_class.new(attrs, options, doc_attrs[:required], self) @api.namespace_stackable(:validations, value) else fail Grape::Exceptions::UnknownValidator.new(type) end end def validate_value_coercion(coerce_type, values) return unless coerce_type && values return if values.is_a?(Proc) coerce_type = coerce_type.first if coerce_type.is_a?(Array) value_types = values.is_a?(Range) ? [values.begin, values.end] : values if coerce_type == Virtus::Attribute::Boolean value_types = value_types.map { |type| Virtus::Attribute.build(type) } end return unless value_types.any? { |v| !v.is_a?(coerce_type) } fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values) end def extract_message_option(attrs) return nil unless attrs.is_a?(Array) opts = attrs.last.is_a?(Hash) ? attrs.pop : {} (opts.key?(:message) && !opts[:message].nil?) ? opts.delete(:message) : nil end def options_key?(type, key, validations) validations[type].respond_to?(:key?) && validations[type].key?(key) && !validations[type][key].nil? end end end end grape-0.16.2/lib/grape/validations/types.rb0000644000004100000410000001223512706307016020605 0ustar www-datawww-datarequire_relative 'types/build_coercer' require_relative 'types/custom_type_coercer' require_relative 'types/multiple_type_coercer' require_relative 'types/variant_collection_coercer' require_relative 'types/json' require_relative 'types/file' # Patch for Virtus::Attribute::Collection # See the file for more details require_relative 'types/virtus_collection_patch' module Grape module Validations # Module for code related to grape's system for # coercion and type validation of incoming request # parameters. # # Grape uses a number of tests and assertions to # work out exactly how a parameter should be handled, # based on the +type+ and +coerce_with+ options that # may be supplied to {Grape::Dsl::Parameters#requires} # and {Grape::Dsl::Parameters#optional}. The main # entry point for this process is {Types.build_coercer}. module Types # Instances of this class may be used as tokens to denote that # a parameter value could not be coerced. class InvalidValue; end # Types representing a single value, which are coerced through Virtus # or special logic in Grape. PRIMITIVES = [ # Numerical Integer, Float, BigDecimal, Numeric, # Date/time Date, DateTime, Time, # Misc Virtus::Attribute::Boolean, String, Symbol, Rack::Multipart::UploadedFile ] # Types representing data structures. STRUCTURES = [ Hash, Array, Set ] # Types for which Grape provides special coercion # and type-checking logic. SPECIAL = { JSON => Json, Array[JSON] => JsonArray, ::File => File, Rack::Multipart::UploadedFile => File } GROUPS = [ Array, Hash, JSON, Array[JSON] ] # Is the given class a primitive type as recognized by Grape? # # @param type [Class] type to check # @return [Boolean] whether or not the type is known by Grape as a valid # type for a single value def self.primitive?(type) PRIMITIVES.include?(type) end # Is the given class a standard data structure (collection or map) # as recognized by Grape? # # @param type [Class] type to check # @return [Boolean] whether or not the type is known by Grape as a valid # data structure type # @note This method does not yet consider 'complex types', which inherit # Virtus.model. def self.structure?(type) STRUCTURES.include?(type) end # Is the declared type in fact an array of multiple allowed types? # For example the declaration +types: [Integer,String]+ will attempt # first to coerce given values to integer, but will also accept any # other string. # # @param type [Array,Set] type (or type list!) to check # @return [Boolean] +true+ if the given value will be treated as # a list of types. def self.multiple?(type) (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1 end # Does the given class implement a type system that Grape # (i.e. the underlying virtus attribute system) supports # out-of-the-box? Currently supported are +axiom-types+ # and +virtus+. # # The type will be passed to +Virtus::Attribute.build+, # and the resulting attribute object will be expected to # respond correctly to +coerce+ and +value_coerced?+. # # @param type [Class] type to check # @return [Boolean] +true+ where the type is recognized def self.recognized?(type) return false if type.is_a?(Array) || type.is_a?(Set) type.is_a?(Virtus::Attribute) || type.ancestors.include?(Axiom::Types::Type) || type.include?(Virtus::Model::Core) end # Does Grape provide special coercion and validation # routines for the given class? This does not include # automatic handling for primitives, structures and # otherwise recognized types. See {Types::SPECIAL}. # # @param type [Class] type to check # @return [Boolean] +true+ if special routines are available def self.special?(type) SPECIAL.key? type end # Is the declared type a supported group type? # Currently supported group types are Array, Hash, JSON, and Array[JSON] # # @param type [Array,Class] type to check # @return [Boolean] +true+ if the type is a supported group type def self.group?(type) GROUPS.include? type end # A valid custom type must implement a class-level `parse` method, taking # one String argument and returning the parsed value in its correct type. # @param type [Class] type to check # @return [Boolean] whether or not the type can be used as a custom type def self.custom?(type) !primitive?(type) && !structure?(type) && !multiple?(type) && !recognized?(type) && !special?(type) && type.respond_to?(:parse) && type.method(:parse).arity == 1 end end end end grape-0.16.2/lib/grape/validations/types/0000755000004100000410000000000012706307016020255 5ustar www-datawww-datagrape-0.16.2/lib/grape/validations/types/multiple_type_coercer.rb0000644000004100000410000000627712706307016025214 0ustar www-datawww-datamodule Grape module Validations module Types # This class is intended for use with Grape endpoint parameters that # have been declared to be of variant-type using the +:types+ option. # +MultipleTypeCoercer+ will build a coercer for each type declared # in the array passed to +:types+ using {Types.build_coercer}. It will # apply these coercers to parameter values in the order given to # +:types+, and will return the value returned by the first coercer # to successfully coerce the parameter value. Therefore if +String+ is # an allowed type it should be declared last, since it will always # successfully "coerce" the value. class MultipleTypeCoercer # Construct a new coercer that will attempt to coerce # values to the given list of types in the given order. # # @param types [Array] list of allowed types # @param method [#call,#parse] method by which values should be # coerced. See class docs for default behaviour. def initialize(types, method = nil) @method = method.respond_to?(:parse) ? method.method(:parse) : method @type_coercers = types.map do |type| if Types.multiple? type VariantCollectionCoercer.new type else Types.build_coercer type end end end # This method is called from somewhere within # +Virtus::Attribute::coerce+ in order to coerce # the given value. # # @param value [String] value to be coerced, in grape # this should always be a string. # @return [Object,InvalidValue] the coerced result, or an instance # of {InvalidValue} if the value could not be coerced. def call(value) return @method.call(value) if @method @type_coercers.each do |coercer| coerced = coercer.coerce(value) return coerced if coercer.value_coerced? coerced end # Declare that we couldn't coerce the value in such a way # that Grape won't ask us again if the value is valid InvalidValue.new end # This method is called from somewhere within # +Virtus::Attribute::value_coerced?+ in order to # assert that the value has been coerced successfully. # Due to Grape's design this will in fact only be called # if a custom coercion method is being used, since {#call} # returns an {InvalidValue} object if the value could not # be coerced. # # @param _primitive [Axiom::Types::Type] primitive type # for the coercion as detected by axiom-types' inference # system. For custom types this is typically not much use # (i.e. it is +Axiom::Types::Object+) unless special # inference rules have been declared for the type. # @param value [Object] a coerced result returned from {#call} # @return [true,false] whether or not the coerced value # satisfies type requirements. def success?(_primitive, value) @type_coercers.any? { |coercer| coercer.value_coerced? value } end end end end end grape-0.16.2/lib/grape/validations/types/json.rb0000644000004100000410000000417412706307016021561 0ustar www-datawww-datarequire 'json' module Grape module Validations module Types # +Virtus::Attribute+ implementation that handles coercion # and type checking for parameters that are complex types # given as JSON-encoded strings. It accepts both JSON objects # and arrays of objects, and will coerce the input to a +Hash+ # or +Array+ object respectively. In either case the Grape # validation system will apply nested validation rules to # all returned objects. class Json < Virtus::Attribute # Coerce the input into a JSON-like data structure. # # @param input [String] a JSON-encoded parameter value # @return [Hash,Array,nil] def coerce(input) # Allow nulls and blank strings return if input.nil? || input =~ /^\s*$/ JSON.parse(input, symbolize_names: true) end # Checks that the input was parsed successfully # and isn't something odd such as an array of primitives. # # @param value [Object] result of {#coerce} # @return [true,false] def value_coerced?(value) value.is_a?(::Hash) || coerced_collection?(value) end protected # Is the value an array of JSON-like objects? # # @param value [Object] result of {#coerce} # @return [true,false] def coerced_collection?(value) value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash } end end # Specialization of the {Json} attribute that is guaranteed # to return an array of objects. Accepts both JSON-encoded # objects and arrays of objects, but wraps single objects # in an Array. class JsonArray < Json # See {Json#coerce}. Wraps single objects in an array. # # @param input [String] JSON-encoded parameter value # @return [Array] def coerce(input) json = super Array.wrap(json) unless json.nil? end # See {Json#coerced_collection?} def value_coerced?(value) coerced_collection? value end end end end end grape-0.16.2/lib/grape/validations/types/variant_collection_coercer.rb0000644000004100000410000000437412706307016026173 0ustar www-datawww-datamodule Grape module Validations module Types # This class wraps {MultipleTypeCoercer}, for use with collections # that allow members of more than one type. class VariantCollectionCoercer < Virtus::Attribute # Construct a new coercer that will attempt to coerce # a list of values such that all members are of one of # the given types. The container may also optionally be # coerced to a +Set+. An arbitrary coercion +method+ may # be supplied, which will be passed the entire collection # as a parameter and should return a new collection, or # may return the same one if no coercion was required. # # @param types [Array,Set] list of allowed types, # also specifying the container type # @param method [#call,#parse] method by which values should be coerced def initialize(types, method = nil) @types = types @method = method.respond_to?(:parse) ? method.method(:parse) : method # If we have a coercion method, pass it in here to save # building another one, even though we call it directly. @member_coercer = MultipleTypeCoercer.new types, method end # Coerce the given value. # # @param value [Array] collection of values to be coerced # @return [Array,Set,InvalidValue] # the coerced result, or an instance # of {InvalidValue} if the value could not be coerced. def coerce(value) return InvalidValue.new unless value.is_a? Array value = if @method @method.call(value) else value.map { |v| @member_coercer.call(v) } end return Set.new value if @types.is_a? Set value end # Assert that the value has been coerced successfully. # # @param value [Object] a coerced result returned from {#coerce} # @return [true,false] whether or not the coerced value # satisfies type requirements. def value_coerced?(value) value.is_a?(@types.class) && value.all? { |v| @member_coercer.success?(@types, v) } end end end end end grape-0.16.2/lib/grape/validations/types/custom_type_coercer.rb0000644000004100000410000001570512706307016024667 0ustar www-datawww-datamodule Grape module Validations module Types # Instances of this class may be passed to # +Virtus::Attribute.build+ as the +:coercer+ # option for custom types that do not otherwise # satisfy the requirements for +Virtus::Attribute::coerce+ # and +Virtus::Attribute::value_coerced?+ to work # as expected. # # Subclasses of +Virtus::Attribute+ or +Axiom::Types::Type+ # (or for which an axiom type can be inferred, i.e. the # primitives, +Date+, +Time+, etc.) do not need any such # coercer to be passed with them. # # Coercion # -------- # # This class will detect type classes that implement # a class-level +parse+ method. The method should accept one # +String+ argument and should return the value coerced to # the appropriate type. The method may raise an exception if # there are any problems parsing the string. # # Alternately an optional +method+ may be supplied (see the # +coerce_with+ option of {Grape::Dsl::Parameters#requires}). # This may be any class or object implementing +parse+ or +call+, # with the same contract as described above. # # Type Checking # ------------- # # Calls to +value_coerced?+ will consult this class to check # that the coerced value produced above is in fact of the # expected type. By default this class performs a basic check # against the type supplied, but this behaviour will be # overridden if the class implements a class-level # +coerced?+ or +parsed?+ method. This method # will receive a single parameter that is the coerced value # and should return +true+ iff the value meets type expectations. # Arbitrary assertions may be made here but the grape validation # system should be preferred. # # Alternately a proc or other object responding to +call+ may be # supplied in place of a type. This should implement the same # contract as +coerced?+, and must be supplied with a coercion # +method+. class CustomTypeCoercer # Uses +Virtus::Attribute.build+ to build a new # attribute that makes use of this class for # coercion and type validation logic. # # @return [Virtus::Attribute] def self.build(type, method = nil) Virtus::Attribute.build(type, coercer: new(type, method)) end # A new coercer for the given type specification # and coercion method. # # @param type [Class,#coerced?,#parsed?,#call?] # specifier for the target type. See class docs. # @param method [#parse,#call] # optional coercion method. See class docs. def initialize(type, method = nil) coercion_method = infer_coercion_method type, method @method = enforce_symbolized_keys type, coercion_method @type_check = infer_type_check(type) end # This method is called from somewhere within # +Virtus::Attribute::coerce+ in order to coerce # the given value. # # @param value [String] value to be coerced, in grape # this should always be a string. # @return [Object] the coerced result def call(value) @method.call value end # This method is called from somewhere within # +Virtus::Attribute::value_coerced?+ in order to # assert that the value has been coerced successfully. # # @param _primitive [Axiom::Types::Type] primitive type # for the coercion as detected by axiom-types' inference # system. For custom types this is typically not much use # (i.e. it is +Axiom::Types::Object+) unless special # inference rules have been declared for the type. # @param value [Object] a coerced result returned from {#call} # @return [true,false] whether or not the coerced value # satisfies type requirements. def success?(_primitive, value) @type_check.call value end private # Determine the coercion method we're expected to use # based on the parameters given. # # @param type see #new # @param method see #new # @return [#call] coercion method def infer_coercion_method(type, method) if method if method.respond_to? :parse method.method :parse else method end else # Try to use parse() declared on the target type. # This may raise an exception, but we are out of ideas anyway. type.method :parse end end # Determine how the type validity of a coerced # value should be decided. # # @param type see #new # @return [#call] a procedure which accepts a single parameter # and returns +true+ if the passed object is of the correct type. def infer_type_check(type) # First check for special class methods if type.respond_to? :coerced? type.method :coerced? elsif type.respond_to? :parsed? type.method :parsed? elsif type.respond_to? :call # Arbitrary proc passed for type validation. # Note that this will fail unless a method is also # passed, or if the type also implements a parse() method. type elsif type.is_a?(Enumerable) ->(value) { value.all? { |item| item.is_a? type[0] } } else # By default, do a simple type check ->(value) { value.is_a? type } end end # Enforce symbolized keys for complex types # by wrapping the coercion method such that # any Hash objects in the immediate heirarchy # are passed through +Hashie.symbolize_keys!+. # This helps common libs such as JSON to work easily. # # @param type see #new # @param method see #infer_coercion_method # @return [#call] +method+ wrapped in an additional # key-conversion step, or just returns +method+ # itself if no conversion is deemed to be # necessary. def enforce_symbolized_keys(type, method) # Collections have all values processed individually if type == Array || type == Set lambda do |val| method.call(val).tap do |new_value| new_value.each do |item| Hashie.symbolize_keys!(item) if item.is_a? Hash end end end # Hash objects are processed directly elsif type == Hash lambda do |val| Hashie.symbolize_keys! method.call(val) end # Simple types are not processed. # This includes Array types. else method end end end end end end grape-0.16.2/lib/grape/validations/types/virtus_collection_patch.rb0000644000004100000410000000106312706307016025530 0ustar www-datawww-datarequire 'virtus/attribute/collection' # See https://github.com/solnic/virtus/pull/343 # This monkey-patch fixes type validation for collections, # ensuring that type assertions are applied to collection # members. # # This patch duplicates the code in the above pull request. # Once the request, or equivalent functionality, has been # published into the +virtus+ gem this file should be deleted. Virtus::Attribute::Collection.class_eval do # @api public def value_coerced?(value) super && value.all? { |item| member_type.value_coerced? item } end end grape-0.16.2/lib/grape/validations/types/file.rb0000644000004100000410000000163112706307016021522 0ustar www-datawww-datamodule Grape module Validations module Types # +Virtus::Attribute+ implementation for parameters # that are multipart file objects. Actual handling # of these objects is provided by +Rack::Request+; # this class is here only to assert that rack's # handling has succeeded, and to prevent virtus # from interfering. class File < Virtus::Attribute def coerce(input) # Processing of multipart file objects # is already taken care of by Rack::Request. # Nothing to do here. input end def value_coerced?(value) # Rack::Request creates a Hash with filename, # content type and an IO object. Grape wraps that # using hashie for convenience. Do a bit of basic # duck-typing. value.is_a?(Hashie::Mash) && value.key?(:tempfile) end end end end end grape-0.16.2/lib/grape/validations/types/build_coercer.rb0000644000004100000410000000365612706307016023415 0ustar www-datawww-datamodule Grape module Validations module Types # Work out the +Virtus::Attribute+ object to # use for coercing strings to the given +type+. # Coercion +method+ will be inferred if none is # supplied. # # If a +Virtus::Attribute+ object already built # with +Virtus::Attribute.build+ is supplied as # the +type+ it will be returned and +method+ # will be ignored. # # See {CustomTypeCoercer} for further details # about coercion and type-checking inference. # # @param type [Class] the type to which input strings # should be coerced # @param method [Class,#call] the coercion method to use # @return [Virtus::Attribute] object to be used # for coercion and type validation def self.build_coercer(type, method = nil) # Accept pre-rolled virtus attributes without interference return type if type.is_a? Virtus::Attribute converter_options = { nullify_blank: true } conversion_type = type # Use a special coercer for multiply-typed parameters. if Types.multiple?(type) converter_options[:coercer] = Types::MultipleTypeCoercer.new(type, method) conversion_type = Object # Use a special coercer for custom types and coercion methods. elsif method || Types.custom?(type) converter_options[:coercer] = Types::CustomTypeCoercer.new(type, method) # Grape swaps in its own Virtus::Attribute implementations # for certain special types that merit first-class support # (but not if a custom coercion method has been supplied). elsif Types.special?(type) conversion_type = Types::SPECIAL[type] end # Virtus will infer coercion and validation rules # for many common ruby types. Virtus::Attribute.build(conversion_type, converter_options) end end end end grape-0.16.2/lib/grape/validations/validators/0000755000004100000410000000000012706307016021261 5ustar www-datawww-datagrape-0.16.2/lib/grape/validations/validators/default.rb0000644000004100000410000000131512706307016023232 0ustar www-datawww-datamodule Grape module Validations class DefaultValidator < Base def initialize(attrs, options, required, scope) @default = options super end def validate_param!(attr_name, params) params[attr_name] = @default.is_a?(Proc) ? @default.call : @default unless params.key?(attr_name) end def validate!(params) return unless @scope.should_validate?(params) attrs = AttributesIterator.new(self, @scope, params) attrs.each do |resource_params, attr_name| if resource_params.is_a?(Hash) && resource_params[attr_name].nil? validate_param!(attr_name, resource_params) end end end end end end grape-0.16.2/lib/grape/validations/validators/values.rb0000644000004100000410000000147412706307016023113 0ustar www-datawww-datamodule Grape module Validations class ValuesValidator < Base def initialize(attrs, options, required, scope) @values = (options_key?(:value, options) ? options[:value] : options) super end def validate_param!(attr_name, params) return unless params.is_a?(Hash) return unless params[attr_name] || required_for_root_scope? values = @values.is_a?(Proc) ? @values.call : @values param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name]) return if param_array.all? { |param| values.include?(param) } fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values) end private def required_for_root_scope? @required && @scope.root? end end end end grape-0.16.2/lib/grape/validations/validators/exactly_one_of.rb0000644000004100000410000000154412706307016024610 0ustar www-datawww-datamodule Grape module Validations require 'grape/validations/validators/mutual_exclusion' class ExactlyOneOfValidator < MutualExclusionValidator def validate!(params) super if scope_requires_params && none_of_restricted_params_is_present fail Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one) end params end def message(default_key = nil) options = instance_variable_get(:@option) if options_key?(:message) (options_key?(default_key, options[:message]) ? options[:message][default_key] : options[:message]) else default_key end end private def none_of_restricted_params_is_present scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? } end end end end grape-0.16.2/lib/grape/validations/validators/all_or_none.rb0000644000004100000410000000113312706307016024073 0ustar www-datawww-datamodule Grape module Validations require 'grape/validations/validators/multiple_params_base' class AllOrNoneOfValidator < MultipleParamsBase def validate!(params) super if scope_requires_params && only_subset_present fail Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none) end params end private def only_subset_present scoped_params.any? { |resource_params| keys_in_common(resource_params).length > 0 && keys_in_common(resource_params).length < attrs.length } end end end end grape-0.16.2/lib/grape/validations/validators/coerce.rb0000644000004100000410000000365312706307016023055 0ustar www-datawww-datamodule Grape class API Boolean = Virtus::Attribute::Boolean end module Validations class CoerceValidator < Base def initialize(*_args) super @converter = Types.build_coercer(type, @option[:method]) end def validate_param!(attr_name, params) fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash new_value = coerce_value(params[attr_name]) if valid_type?(new_value) params[attr_name] = new_value else fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) end end private # @!attribute [r] converter # Object that will be used for parameter coercion and type checking. # # See {Types.build_coercer} # # @return [Virtus::Attribute] attr_reader :converter def valid_type?(val) # Special value to denote coercion failure return false if val.instance_of?(Types::InvalidValue) # Allow nil, to ignore when a parameter is absent return true if val.nil? converter.value_coerced? val end def coerce_value(val) # Don't coerce things other than nil to Arrays or Hashes unless (@option[:method] && !val.nil?) || type.is_a?(Virtus::Attribute) return val || [] if type == Array return val || Set.new if type == Set return val || {} if type == Hash end converter.coerce(val) # not the prettiest but some invalid coercion can currently trigger # errors in Virtus (see coerce_spec.rb:75) rescue Types::InvalidValue.new end # Type to which the parameter will be coerced. # # @return [Class] def type @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type] end end end end grape-0.16.2/lib/grape/validations/validators/multiple_params_base.rb0000644000004100000410000000110012706307016025766 0ustar www-datawww-datamodule Grape module Validations class MultipleParamsBase < Base attr_reader :scoped_params def validate!(params) @scoped_params = [@scope.params(params)].flatten params end private def scope_requires_params @scope.required? || scoped_params.any?(&:any?) end def keys_in_common(resource_params) return [] unless resource_params.is_a?(Hash) (all_keys & resource_params.stringify_keys.keys).map(&:to_s) end def all_keys attrs.map(&:to_s) end end end end grape-0.16.2/lib/grape/validations/validators/presence.rb0000644000004100000410000000065612706307016023421 0ustar www-datawww-datamodule Grape module Validations class PresenceValidator < Base def validate!(params) return unless @scope.should_validate?(params) super end def validate_param!(attr_name, params) return if params.respond_to?(:key?) && params.key?(attr_name) fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence) end end end end grape-0.16.2/lib/grape/validations/validators/base.rb0000644000004100000410000000477112706307016022531 0ustar www-datawww-datamodule Grape module Validations class Base attr_reader :attrs # Creates a new Validator from options specified # by a +requires+ or +optional+ directive during # parameter definition. # @param attrs [Array] names of attributes to which the Validator applies # @param options [Object] implementation-dependent Validator options # @param required [Boolean] attribute(s) are required or optional # @param scope [ParamsScope] parent scope for this Validator def initialize(attrs, options, required, scope) @attrs = Array(attrs) @option = options @required = required @scope = scope end # Validates a given request. # @note This method must be thread-safe. # @note Override #validate! unless you need to access the entire request. # @param request [Grape::Request] the request currently being handled # @raise [Grape::Exceptions::Validation] if validation failed # @return [void] def validate(request) validate!(request.params) end # Validates a given parameter hash. # @note This method must be thread-safe. # @note Override #validate iff you need to access the entire request. # @param params [Hash] parameters to validate # @raise [Grape::Exceptions::Validation] if validation failed # @return [void] def validate!(params) attributes = AttributesIterator.new(self, @scope, params) attributes.each do |resource_params, attr_name| if @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name)) validate_param!(attr_name, resource_params) end end end def self.convert_to_short_name(klass) ret = klass.name.gsub(/::/, '/') .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2') .gsub(/([a-z\d])([A-Z])/, '\1_\2') .tr('-', '_') .downcase File.basename(ret, '_validator') end def self.inherited(klass) short_name = convert_to_short_name(klass) Validations.register_validator(short_name, klass) end def message(default_key = nil) options = instance_variable_get(:@option) options_key?(:message) ? options[:message] : default_key end def options_key?(key, options = nil) options = instance_variable_get(:@option) if options.nil? options.respond_to?(:key?) && options.key?(key) && !options[key].nil? end end end end grape-0.16.2/lib/grape/validations/validators/at_least_one_of.rb0000644000004100000410000000107012706307016024725 0ustar www-datawww-datamodule Grape module Validations require 'grape/validations/validators/multiple_params_base' class AtLeastOneOfValidator < MultipleParamsBase def validate!(params) super if scope_requires_params && no_exclusive_params_are_present fail Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one) end params end private def no_exclusive_params_are_present scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? } end end end end grape-0.16.2/lib/grape/validations/validators/allow_blank.rb0000644000004100000410000000211412706307016024071 0ustar www-datawww-datamodule Grape module Validations class AllowBlankValidator < Base def validate_param!(attr_name, params) return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash) value = params[attr_name] value = value.strip if value.respond_to?(:strip) key_exists = params.key?(attr_name) if @scope.root? # root scope. validate if it's a required param. if it's optional, validate only if key exists in hash should_validate = @required || key_exists else # nested scope should_validate = # required param, and scope contains some values (if scoping element contains no values, treat as blank) (@required && params.present?) || # optional param but key inside scoping element exists (!@required && params.key?(attr_name)) end return unless should_validate return if value == false || value.present? fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:blank) end end end end grape-0.16.2/lib/grape/validations/validators/mutual_exclusion.rb0000644000004100000410000000132212706307016025204 0ustar www-datawww-datamodule Grape module Validations require 'grape/validations/validators/multiple_params_base' class MutualExclusionValidator < MultipleParamsBase attr_reader :processing_keys_in_common def validate!(params) super if two_or_more_exclusive_params_are_present fail Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion) end params end private def two_or_more_exclusive_params_are_present scoped_params.any? do |resource_params| @processing_keys_in_common = keys_in_common(resource_params) @processing_keys_in_common.length > 1 end end end end end grape-0.16.2/lib/grape/validations/validators/regexp.rb0000644000004100000410000000062412706307016023102 0ustar www-datawww-datamodule Grape module Validations class RegexpValidator < Base def validate_param!(attr_name, params) return unless params.key?(attr_name) && !params[attr_name].nil? && !(params[attr_name].to_s =~ (options_key?(:value) ? @option[:value] : @option)) fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp) end end end end grape-0.16.2/lib/grape/validations/attributes_iterator.rb0000644000004100000410000000116312706307016023536 0ustar www-datawww-datamodule Grape module Validations class AttributesIterator include Enumerable attr_reader :scope def initialize(validator, scope, params) @scope = scope @attrs = validator.attrs @params = Array.wrap(scope.params(params)) end def each @params.each do |resource_params| @attrs.each_with_index do |attr_name, index| if resource_params.is_a?(Hash) && resource_params[attr_name].is_a?(Array) scope.index = index end yield resource_params, attr_name end end end end end end grape-0.16.2/lib/grape/router/0000755000004100000410000000000012706307016016114 5ustar www-datawww-datagrape-0.16.2/lib/grape/router/pattern.rb0000644000004100000410000000275412706307016020126 0ustar www-datawww-datarequire 'forwardable' require 'mustermann/grape' module Grape class Router class Pattern DEFAULT_PATTERN_OPTIONS = { uri_decode: true, type: :grape }.freeze DEFAULT_SUPPORTED_CAPTURE = [:format, :version].freeze attr_reader :origin, :path, :capture, :pattern extend Forwardable def_delegators :pattern, :named_captures, :params def_delegators :@regexp, :=== alias_method :match?, :=== def initialize(pattern, options = {}) @origin = pattern @path = build_path(pattern, options) @capture = extract_capture(options) @pattern = Mustermann.new(@path, pattern_options) @regexp = to_regexp end def to_regexp @to_regexp ||= @pattern.to_regexp end private def pattern_options options = DEFAULT_PATTERN_OPTIONS.dup options.merge!(capture: capture) if capture.present? options end def build_path(pattern, options = {}) pattern << '*path' unless options[:anchor] || pattern.end_with?('*path') pattern + options[:suffix].to_s end def extract_capture(options = {}) requirements = {}.merge(options[:requirements]) supported_capture.each_with_object(requirements) do |field, capture| option = Array(options[field]) capture[field] = option.map(&:to_s) if option.present? end end def supported_capture DEFAULT_SUPPORTED_CAPTURE end end end end grape-0.16.2/lib/grape/router/attribute_translator.rb0000644000004100000410000000123412706307016022715 0ustar www-datawww-datamodule Grape class Router # this could be an OpenStruct, but doesn't work in Ruby 2.3.0, see https://bugs.ruby-lang.org/issues/12251 class AttributeTranslator def initialize(attributes = {}) @attributes = attributes end def to_h @attributes end def method_missing(m, *args) if m[-1] == '=' @attributes[m[0..-1]] = *args else @attributes[m] end end def respond_to_missing?(method_name, _include_private = false) if method_name[-1] == '=' true else @attributes.key?(method_name) end end end end end grape-0.16.2/lib/grape/router/route.rb0000644000004100000410000000551212706307016017602 0ustar www-datawww-datarequire 'grape/router/pattern' require 'grape/router/attribute_translator' require 'forwardable' require 'pathname' module Grape class Router class Route ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/.freeze SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze FIXED_NAMED_CAPTURES = %w(format version).freeze attr_accessor :pattern, :translator, :app, :index, :regexp, :options alias_method :attributes, :translator extend Forwardable def_delegators :pattern, :path, :origin def method_missing(method_id, *arguments) match = ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s) if match method_name = match.captures.last.to_sym warn_route_methods(method_name, caller(1).shift) @options[method_name] else super end end [ :prefix, :version, :settings, :format, :description, :http_codes, :headers, :entity, :details, :requirements, :request_method, :namespace ].each do |method_name| define_method method_name do attributes.public_send method_name end end def route_method warn_route_methods(:method, caller(1).shift, :request_method) request_method end def route_path warn_route_methods(:path, caller(1).shift) pattern.path end def initialize(method, pattern, options = {}) @suffix = options[:suffix] @options = options.merge(method: method.to_s.upcase) @pattern = Pattern.new(pattern, options) @translator = AttributeTranslator.new(options.merge(request_method: method.to_s.upcase)) end def exec(env) @app.call(env) end def apply(app) @app = app self end def match?(input) translator.respond_to?(:forward_match) && translator.forward_match ? input.start_with?(pattern.origin) : pattern.match?(input) end def params(input = nil) if input.nil? pattern.named_captures.keys.each_with_object(translator.params) do |(key), defaults| defaults[key] ||= '' unless FIXED_NAMED_CAPTURES.include?(key) || defaults.key?(key) end else parsed = pattern.params(input) parsed ? parsed.delete_if { |_, value| value.nil? }.symbolize_keys : {} end end private def warn_route_methods(name, location, expected = nil) path, line = *location.scan(SOURCE_LOCATION_REGEXP).first path = File.realpath(path) if Pathname.new(path).relative? expected ||= name warn <<-EOS #{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}. EOS end end end end grape-0.16.2/lib/grape/dsl/0000755000004100000410000000000012706307016015356 5ustar www-datawww-datagrape-0.16.2/lib/grape/dsl/headers.rb0000644000004100000410000000055412706307016017322 0ustar www-datawww-datamodule Grape module DSL module Headers # Set an individual header or retrieve # all headers that have been set. def header(key = nil, val = nil) if key val ? header[key.to_s] = val : header.delete(key.to_s) else @header ||= {} end end alias_method :headers, :header end end end grape-0.16.2/lib/grape/dsl/inside_route.rb0000644000004100000410000002702412706307016020401 0ustar www-datawww-datarequire 'active_support/concern' require 'grape/dsl/headers' module Grape module DSL module InsideRoute extend ActiveSupport::Concern include Grape::DSL::Settings include Grape::DSL::Headers # Denotes a situation where a DSL method has been invoked in a # filter which it should not yet be available in class MethodNotYetAvailable < StandardError; end # @param type [Symbol] The type of filter for which evaluation has been # completed # @return [Module] A module containing method overrides suitable for the # position in the filter evaluation sequence denoted by +type+. This # defaults to an empty module if no overrides are defined for the given # filter +type+. def self.post_filter_methods(type) @post_filter_modules ||= { before: PostBeforeFilter } @post_filter_modules[type] end # Methods which should not be available in filters until the before filter # has completed module PostBeforeFilter def declared(params, options = {}, declared_params = nil) options = options.reverse_merge(include_missing: true, include_parent_namespaces: true) declared_params ||= (!options[:include_parent_namespaces] ? route_setting(:declared_params) : (route_setting(:saved_declared_params) || [])).flatten(1) || [] fail ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params if params.is_a? Array params.map do |param| declared(param || {}, options, declared_params) end else declared_params.each_with_object(Hashie::Mash.new) do |key, hash| key = { key => nil } unless key.is_a? Hash key.each_pair do |parent, children| output_key = options[:stringify] ? parent.to_s : parent.to_sym next unless options[:include_missing] || params.key?(parent) hash[output_key] = if children children_params = params[parent] || (children.is_a?(Array) ? [] : {}) declared(children_params, options, Array(children)) else params[parent] end end end end end end # A filtering method that will return a hash # consisting only of keys that have been declared by a # `params` statement against the current/target endpoint or parent # namespaces. # # @see +PostBeforeFilter#declared+ # # @param params [Hash] The initial hash to filter. Usually this will just be `params` # @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces` # options. `:include_parent_namespaces` defaults to true, hence must be set to false if # you want only to return params declared against the current/target endpoint. def declared(*) fail MethodNotYetAvailable, '#declared is not available prior to parameter validation.' end # The API version as specified in the URL. def version env[Grape::Env::API_VERSION] end # End the request and display an error to the # end user with the specified message. # # @param message [String] The message to display. # @param status [Integer] the HTTP Status Code. Defaults to default_error_status, 500 if not set. def error!(message, status = nil, headers = nil) self.status(status || namespace_inheritable(:default_error_status)) throw :error, message: message, status: self.status, headers: headers end # Redirect to a new url. # # @param url [String] The url to be redirect. # @param options [Hash] The options used when redirect. # :permanent, default false. # :body, default a short message including the URL. def redirect(url, options = {}) permanent = options.fetch(:permanent, false) body_message = options.fetch(:body, nil) if permanent status 301 body_message ||= "This resource has been moved permanently to #{url}." else if env[Grape::Http::Headers::HTTP_VERSION] == 'HTTP/1.1' && request.request_method.to_s.upcase != Grape::Http::Headers::GET status 303 body_message ||= "An alternate resource is located at #{url}." else status 302 body_message ||= "This resource has been moved temporarily to #{url}." end end header 'Location', url content_type 'text/plain' body body_message end # Set or retrieve the HTTP status code. # # @param status [Integer] The HTTP Status Code to return for this request. def status(status = nil) case status when Symbol if Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.include?(status) @status = Rack::Utils.status_code(status) else fail ArgumentError, "Status code :#{status} is invalid." end when Fixnum @status = status when nil return @status if @status case request.request_method.to_s.upcase when Grape::Http::Headers::POST 201 else 200 end else fail ArgumentError, 'Status code must be Fixnum or Symbol.' end end # Set response content-type def content_type(val = nil) if val header(Grape::Http::Headers::CONTENT_TYPE, val) else header[Grape::Http::Headers::CONTENT_TYPE] end end # Set or get a cookie # # @example # cookies[:mycookie] = 'mycookie val' # cookies['mycookie-string'] = 'mycookie string val' # cookies[:more] = { value: '123', expires: Time.at(0) } # cookies.delete :more # def cookies @cookies ||= Cookies.new end # Allows you to define the response body as something other than the # return value. # # @example # get '/body' do # body "Body" # "Not the Body" # end # # GET /body # => "Body" def body(value = nil) if value @body = value elsif value == false @body = '' status 204 else @body end end # Allows you to define the response as a file-like object. # # @example # get '/file' do # file FileStreamer.new(...) # end # # GET /file # => "contents of file" def file(value = nil) if value.is_a?(String) file_body = Grape::ServeFile::FileBody.new(value) @file = Grape::ServeFile::FileResponse.new(file_body) elsif !value.is_a?(NilClass) warn '[DEPRECATION] Argument as FileStreamer-like object is deprecated. Use path to file instead.' @file = Grape::ServeFile::FileResponse.new(value) else @file end end # Allows you to define the response as a streamable object. # # If Content-Length and Transfer-Encoding are blank (among other conditions), # Rack assumes this response can be streamed in chunks. # # @example # get '/stream' do # stream FileStreamer.new(...) # end # # GET /stream # => "chunked contents of file" # # See: # * https://github.com/rack/rack/blob/99293fa13d86cd48021630fcc4bd5acc9de5bdc3/lib/rack/chunked.rb # * https://github.com/rack/rack/blob/99293fa13d86cd48021630fcc4bd5acc9de5bdc3/lib/rack/etag.rb def stream(value = nil) header 'Content-Length', nil header 'Transfer-Encoding', nil header 'Cache-Control', 'no-cache' # Skips ETag generation (reading the response up front) file(value) end # Allows you to make use of Grape Entities by setting # the response body to the serializable hash of the # entity provided in the `:with` option. This has the # added benefit of automatically passing along environment # and version information to the serialization, making it # very easy to do conditional exposures. See Entity docs # for more info. # # @example # # get '/users/:id' do # present User.find(params[:id]), # with: API::Entities::User, # admin: current_user.admin? # end def present(*args) options = args.count > 1 ? args.extract_options! : {} key, object = if args.count == 2 && args.first.is_a?(Symbol) args else [nil, args.first] end entity_class = entity_class_for_obj(object, options) root = options.delete(:root) representation = if entity_class entity_representation_for(entity_class, object, options) else object end representation = { root => representation } if root if key representation = (@body || {}).merge(key => representation) elsif entity_class.present? && @body fail ArgumentError, "Representation of type #{representation.class} cannot be merged." unless representation.respond_to?(:merge) representation = @body.merge(representation) end body representation end # Returns route information for the current request. # # @example # # desc "Returns the route description." # get '/' do # route.description # end def route env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info] end # Attempt to locate the Entity class for a given object, if not given # explicitly. This is done by looking for the presence of Klass::Entity, # where Klass is the class of the `object` parameter, or one of its # ancestors. # @param object [Object] the object to locate the Entity class for # @param options [Hash] # @option options :with [Class] the explicit entity class to use # @return [Class] the located Entity class, or nil if none is found def entity_class_for_obj(object, options) entity_class = options.delete(:with) if entity_class.nil? # entity class not explicitely defined, auto-detect from relation#klass or first object in the collection object_class = if object.respond_to?(:klass) object.klass else object.respond_to?(:first) ? object.first.class : object.class end object_class.ancestors.each do |potential| entity_class ||= (namespace_stackable_with_hash(:representations) || {})[potential] end entity_class ||= object_class.const_get(:Entity) if object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent) end entity_class end # @return the representation of the given object as done through # the given entity_class. def entity_representation_for(entity_class, object, options) embeds = { env: env } embeds[:version] = env[Grape::Env::API_VERSION] if env[Grape::Env::API_VERSION] entity_class.represent(object, embeds.merge(options)) end end end end grape-0.16.2/lib/grape/dsl/request_response.rb0000644000004100000410000001464412706307016021322 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module RequestResponse extend ActiveSupport::Concern include Grape::DSL::Configuration module ClassMethods # Specify the default format for the API's serializers. # May be `:json` or `:txt` (default). def default_format(new_format = nil) namespace_inheritable(:default_format, new_format.nil? ? nil : new_format.to_sym) end # Specify the format for the API's serializers. # May be `:json`, `:xml`, `:txt`, etc. def format(new_format = nil) if new_format namespace_inheritable(:format, new_format.to_sym) # define the default error formatters namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(new_format, {})) # define a single mime type mime_type = content_types[new_format.to_sym] fail Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type namespace_stackable(:content_types, new_format.to_sym => mime_type) else namespace_inheritable(:format) end end # Specify a custom formatter for a content-type. def formatter(content_type, new_formatter) namespace_stackable(:formatters, content_type.to_sym => new_formatter) end # Specify a custom parser for a content-type. def parser(content_type, new_parser) namespace_stackable(:parsers, content_type.to_sym => new_parser) end # Specify a default error formatter. def default_error_formatter(new_formatter_name = nil) if new_formatter_name new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name, {}) namespace_inheritable(:default_error_formatter, new_formatter) else namespace_inheritable(:default_error_formatter) end end def error_formatter(format, options) if options.is_a?(Hash) && options.key?(:with) formatter = options[:with] else formatter = options end namespace_stackable(:error_formatters, format.to_sym => formatter) end # Specify additional content-types, e.g.: # content_type :xls, 'application/vnd.ms-excel' def content_type(key, val) namespace_stackable(:content_types, key.to_sym => val) end # All available content types. def content_types c_types = namespace_stackable_with_hash(:content_types) Grape::ContentTypes.content_types_for c_types end # Specify the default status code for errors. def default_error_status(new_status = nil) namespace_inheritable(:default_error_status, new_status) end # Allows you to rescue certain exceptions that occur to return # a grape error rather than raising all the way to the # server level. # # @example Rescue from custom exceptions # class ExampleAPI < Grape::API # class CustomError < StandardError; end # # rescue_from CustomError # end # # @overload rescue_from(*exception_classes, options = {}) # @param [Array] exception_classes A list of classes that you want to rescue, or # the symbol :all to rescue from all exceptions. # @param [Block] block Execution block to handle the given exception. # @param [Hash] options Options for the rescue usage. # @option options [Boolean] :backtrace Include a backtrace in the rescue response. # @option options [Boolean] :rescue_subclasses Also rescue subclasses of exception classes # @param [Proc] handler Execution proc to handle the given exception as an # alternative to passing a block. def rescue_from(*args, &block) if args.last.is_a?(Proc) handler = args.pop elsif block_given? handler = block end options = args.extract_options! if block_given? && options.key?(:with) fail ArgumentError, 'both :with option and block cannot be passed' end handler ||= extract_with(options) if args.include?(:all) namespace_inheritable(:rescue_all, true) namespace_inheritable :all_rescue_handler, handler else handler_type = case options[:rescue_subclasses] when nil, true :rescue_handlers else :base_only_rescue_handlers end namespace_stackable handler_type, Hash[args.map { |arg| [arg, handler] }] end namespace_stackable(:rescue_options, options) end # Allows you to specify a default representation entity for a # class. This allows you to map your models to their respective # entities once and then simply call `present` with the model. # # @example # class ExampleAPI < Grape::API # represent User, with: Entity::User # # get '/me' do # present current_user # with: Entity::User is assumed # end # end # # Note that Grape will automatically go up the class ancestry to # try to find a representing entity, so if you, for example, define # an entity to represent `Object` then all presented objects will # bubble up and utilize the entity provided on that `represent` call. # # @param model_class [Class] The model class that will be represented. # @option options [Class] :with The entity class that will represent the model. def represent(model_class, options) fail Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class) namespace_stackable(:representations, model_class => options[:with]) end private def extract_with(options) return unless options.key?(:with) with_option = options[:with] return with_option if with_option.instance_of?(Proc) return if with_option.instance_of?(Symbol) || with_option.instance_of?(String) fail ArgumentError, "with: #{with_option.class}, expected Symbol, String or Proc" end end end end end grape-0.16.2/lib/grape/dsl/configuration.rb0000644000004100000410000000043112706307016020550 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module Configuration extend ActiveSupport::Concern module ClassMethods include Grape::DSL::Settings include Grape::DSL::Logger include Grape::DSL::Desc end end end end grape-0.16.2/lib/grape/dsl/logger.rb0000644000004100000410000000101012706307016017152 0ustar www-datawww-datamodule Grape module DSL module Logger include Grape::DSL::Settings attr_writer :logger # Set or retrive the configured logger. If none was configured, this # method will create a new one, logging to stdout. # @param logger [Object] the new logger to use def logger(logger = nil) if logger global_setting(:logger, logger) else global_setting(:logger) || global_setting(:logger, ::Logger.new($stdout)) end end end end end grape-0.16.2/lib/grape/dsl/api.rb0000644000004100000410000000066312706307016016461 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module API extend ActiveSupport::Concern include Grape::Middleware::Auth::DSL include Grape::DSL::Validations include Grape::DSL::Callbacks include Grape::DSL::Configuration include Grape::DSL::Helpers include Grape::DSL::Middleware include Grape::DSL::RequestResponse include Grape::DSL::Routing end end end grape-0.16.2/lib/grape/dsl/helpers.rb0000644000004100000410000000460012706307016017345 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module Helpers extend ActiveSupport::Concern include Grape::DSL::Configuration module ClassMethods # Add helper methods that will be accessible from any # endpoint within this namespace (and child namespaces). # # When called without a block, all known helpers within this scope # are included. # # @param [Module] new_mod optional module of methods to include # @param [Block] block optional block of methods to include # # @example Define some helpers. # # class ExampleAPI < Grape::API # helpers do # def current_user # User.find_by_id(params[:token]) # end # end # end # def helpers(new_mod = nil, &block) if block_given? || new_mod mod = new_mod || Module.new define_boolean_in_mod(mod) inject_api_helpers_to_mod(mod) if new_mod inject_api_helpers_to_mod(mod) do mod.class_eval(&block) end if block_given? namespace_stackable(:helpers, mod) else mod = Module.new namespace_stackable(:helpers).each do |mod_to_include| mod.send :include, mod_to_include end change! mod end end protected def define_boolean_in_mod(mod) return if defined? mod::Boolean mod.const_set('Boolean', Virtus::Attribute::Boolean) end def inject_api_helpers_to_mod(mod, &_block) mod.extend(BaseHelper) unless mod.is_a?(BaseHelper) yield if block_given? mod.api_changed(self) end end # This module extends user defined helpers # to provide some API-specific functionality. module BaseHelper attr_accessor :api def params(name, &block) @named_params ||= {} @named_params[name] = block end def api_changed(new_api) @api = new_api process_named_params end protected def process_named_params return unless @named_params && @named_params.any? api.namespace_stackable(:named_params, @named_params) end end end end end grape-0.16.2/lib/grape/dsl/middleware.rb0000644000004100000410000000155312706307016020024 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module Middleware extend ActiveSupport::Concern include Grape::DSL::Configuration module ClassMethods # Apply a custom middleware to the API. Applies # to the current namespace and any children, but # not parents. # # @param middleware_class [Class] The class of the middleware you'd like # to inject. def use(middleware_class, *args, &block) arr = [middleware_class, *args] arr << block if block_given? namespace_stackable(:middleware, arr) end # Retrieve an array of the middleware classes # and arguments that are currently applied to the # application. def middleware namespace_stackable(:middleware) || [] end end end end end grape-0.16.2/lib/grape/dsl/routing.rb0000644000004100000410000001551112706307016017375 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module Routing extend ActiveSupport::Concern include Grape::DSL::Configuration module ClassMethods attr_reader :endpoints, :routes # Specify an API version. # # @example API with legacy support. # class MyAPI < Grape::API # version 'v2' # # get '/main' do # {some: 'data'} # end # # version 'v1' do # get '/main' do # {legacy: 'data'} # end # end # end # def version(*args, &block) if args.any? options = args.extract_options! options = options.reverse_merge(using: :path) fail Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor) @versions = versions | args if block_given? within_namespace do namespace_inheritable(:version, args) namespace_inheritable(:version_options, options) instance_eval(&block) end else namespace_inheritable(:version, args) namespace_inheritable(:version_options, options) end end @versions.last unless @versions.nil? end # Define a root URL prefix for your entire API. def prefix(prefix = nil) namespace_inheritable(:root_prefix, prefix) end # Create a scope without affecting the URL. # # @param _name [Symbol] Purely placebo, just allows to name the scope to # make the code more readable. def scope(_name = nil, &block) within_namespace do nest(block) end end # Do not route HEAD requests to GET requests automatically. def do_not_route_head! namespace_inheritable(:do_not_route_head, true) end # Do not automatically route OPTIONS. def do_not_route_options! namespace_inheritable(:do_not_route_options, true) end def mount(mounts) mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair) mounts.each_pair do |app, path| in_setting = inheritable_setting if app.respond_to?(:inheritable_setting, true) mount_path = Grape::Router.normalize_path(path) app.top_level_setting.namespace_stackable[:mount_path] = mount_path app.inherit_settings(inheritable_setting) in_setting = app.top_level_setting app.change! change! end endpoints << Grape::Endpoint.new( in_setting, method: :any, path: path, app: app, forward_match: !app.respond_to?(:inheritable_setting), for: self ) end end # Defines a route that will be recognized # by the Grape API. # # @param methods [HTTP Verb] One or more HTTP verbs that are accepted by this route. Set to `:any` if you want any verb to be accepted. # @param paths [String] One or more strings representing the URL segment(s) for this route. # # @example Defining a basic route. # class MyAPI < Grape::API # route(:any, '/hello') do # {hello: 'world'} # end # end def route(methods, paths = ['/'], route_options = {}, &block) endpoint_options = { method: methods, path: paths, for: self, route_options: ({ params: namespace_stackable_with_hash(:params) || {} }).deep_merge(route_setting(:description) || {}).deep_merge(route_options || {}) } new_endpoint = Grape::Endpoint.new(inheritable_setting, endpoint_options, &block) endpoints << new_endpoint unless endpoints.any? { |e| e.equals?(new_endpoint) } route_end reset_validations! end %w(get post put head delete options patch).each do |meth| define_method meth do |*args, &block| options = args.extract_options! paths = args.first || ['/'] route(meth.upcase, paths, options, &block) end end # Declare a "namespace", which prefixes all subordinate routes with its # name. Any endpoints within a namespace, or group, resource, segment, # etc., will share their parent context as well as any configuration # done in the namespace context. # # @example # # namespace :foo do # get 'bar' do # # defines the endpoint: GET /foo/bar # end # end def namespace(space = nil, options = {}, &block) if space || block_given? within_namespace do previous_namespace_description = @namespace_description @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {}) nest(block) do if space namespace_stackable(:namespace, Namespace.new(space, options)) end end @namespace_description = previous_namespace_description end else Namespace.joined_space_path(namespace_stackable(:namespace)) end end alias_method :group, :namespace alias_method :resource, :namespace alias_method :resources, :namespace alias_method :segment, :namespace # An array of API routes. def routes @routes ||= prepare_routes end # Remove all defined routes. def reset_routes! endpoints.each(&:reset_routes!) @routes = nil end def reset_endpoints! @endpoints = [] end # Thie method allows you to quickly define a parameter route segment # in your API. # # @param param [Symbol] The name of the parameter you wish to declare. # @option options [Regexp] You may supply a regular expression that the declared parameter must meet. def route_param(param, options = {}, &block) options = options.dup options[:requirements] = { param.to_sym => options[:requirements] } if options[:requirements].is_a?(Regexp) Grape::Validations::ParamsScope.new(api: self) do requires param, type: options[:type] end if options.key?(:type) namespace(":#{param}", options, &block) end # @return array of defined versions def versions @versions ||= [] end end end end end grape-0.16.2/lib/grape/dsl/parameters.rb0000644000004100000410000001776312706307016020064 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL # Defines DSL methods, meant to be applied to a ParamsScope, which define # and describe the parameters accepted by an endpoint, or all endpoints # within a namespace. module Parameters extend ActiveSupport::Concern # Include reusable params rules among current. # You can define reusable params with helpers method. # # @example # # class API < Grape::API # helpers do # params :pagination do # optional :page, type: Integer # optional :per_page, type: Integer # end # end # # desc "Get collection" # params do # use :pagination # end # get do # Collection.page(params[:page]).per(params[:per_page]) # end # end def use(*names) named_params = @api.namespace_stackable_with_hash(:named_params) || {} options = names.extract_options! names.each do |name| params_block = named_params.fetch(name) do fail "Params :#{name} not found!" end instance_exec(options, ¶ms_block) end end alias_method :use_scope, :use alias_method :includes, :use # Require one or more parameters for the current endpoint. # # @param attrs list of parameter names, or, if :using is # passed as an option, which keys to include (:all or :none) from # the :using hash. The last key can be a hash, which specifies # options for the parameters # @option attrs :type [Class] the type to coerce this parameter to before # passing it to the endpoint. See {Grape::Validations::Types} for a list of # types that are supported automatically. Custom classes may be used # where they define a class-level `::parse` method, or in conjunction # with the `:coerce_with` parameter. `JSON` may be supplied to denote # `JSON`-formatted objects or arrays of objects. `Array[JSON]` accepts # the same values as `JSON` but will wrap single objects in an `Array`. # @option attrs :types [Array] may be supplied in place of +:type+ # to declare an attribute that has multiple allowed types. See # {Validations::Types::MultipleTypeCoercer} for more details on coercion # and validation rules for variant-type parameters. # @option attrs :desc [String] description to document this parameter # @option attrs :default [Object] default value, if parameter is optional # @option attrs :values [Array] permissable values for this field. If any # other value is given, it will be handled as a validation error # @option attrs :using [Hash[Symbol => Hash]] a hash defining keys and # options, like that returned by {Grape::Entity#documentation}. The value # of each key is an options hash accepting the same parameters # @option attrs :except [Array[Symbol]] a list of keys to exclude from # the :using Hash. The meaning of this depends on if :all or :none was # passed; :all + :except will make the :except fields optional, whereas # :none + :except will make the :except fields required # @option attrs :coerce_with [#parse, #call] method to be used when coercing # the parameter to the type named by `attrs[:type]`. Any class or object # that defines `::parse` or `::call` may be used. # # @example # # params do # # Basic usage: require a parameter of a certain type # requires :user_id, type: Integer # # # You don't need to specify type; String is default # requires :foo # # # Multiple params can be specified at once if they share # # the same options. # requires :x, :y, :z, type: Date # # # Nested parameters can be handled as hashes. You must # # pass in a block, within which you can use any of the # # parameters DSL methods. # requires :user, type: Hash do # requires :name, type: String # end # end def requires(*attrs, &block) orig_attrs = attrs.clone opts = attrs.extract_options!.clone opts[:presence] = { value: true, message: opts[:message] } if opts[:using] require_required_and_optional_fields(attrs.first, opts) else validate_attributes(attrs, opts, &block) block_given? ? new_scope(orig_attrs, &block) : push_declared_params(attrs) end end # Allow, but don't require, one or more parameters for the current # endpoint. # @param (see #requires) # @option (see #requires) def optional(*attrs, &block) orig_attrs = attrs.clone opts = attrs.extract_options!.clone type = opts[:type] # check type for optional parameter group if attrs && block_given? fail Grape::Exceptions::MissingGroupTypeError.new if type.nil? fail Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type) end if opts[:using] require_optional_fields(attrs.first, opts) else validate_attributes(attrs, opts, &block) block_given? ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs) end end # Disallow the given parameters to be present in the same request. # @param attrs [*Symbol] parameters to validate def mutually_exclusive(*attrs) validates(attrs, mutual_exclusion: { value: true, message: extract_message_option(attrs) }) end # Require exactly one of the given parameters to be present. # @param (see #mutually_exclusive) def exactly_one_of(*attrs) validates(attrs, exactly_one_of: { value: true, message: extract_message_option(attrs) }) end # Require at least one of the given parameters to be present. # @param (see #mutually_exclusive) def at_least_one_of(*attrs) validates(attrs, at_least_one_of: { value: true, message: extract_message_option(attrs) }) end # Require that either all given params are present, or none are. # @param (see #mutually_exclusive) def all_or_none_of(*attrs) validates(attrs, all_or_none_of: { value: true, message: extract_message_option(attrs) }) end # Define a block of validations which should be applied if and only if # the given parameter is present. The parameters are not nested. # @param attr [Symbol] the parameter which, if present, triggers the # validations # @raise Grape::Exceptions::UnknownParameter if `attr` has not been # defined in this scope yet # @yield a parameter definition DSL def given(*attrs, &block) attrs.each do |attr| fail Grape::Exceptions::UnknownParameter.new(attr) unless declared_param?(attr) end new_lateral_scope(dependent_on: attrs, &block) end # Test for whether a certain parameter has been defined in this params # block yet. # @return [Boolean] whether the parameter has been defined def declared_param?(param) # @declared_params also includes hashes of options and such, but those # won't be flattened out. @declared_params.flatten.include?(param) end alias_method :group, :requires # @param params [Hash] initial hash of parameters # @return hash of parameters relevant for the current scope # @api private def params(params) params = @parent.params(params) if @parent if @element if params.is_a?(Array) params = params.flat_map { |el| el[@element] || {} } elsif params.is_a?(Hash) params = params[@element] || {} else params = {} end end params end end end end grape-0.16.2/lib/grape/dsl/callbacks.rb0000644000004100000410000000256312706307016017630 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL # Blocks can be executed before or after every API call, using `before`, `after`, # `before_validation` and `after_validation`. # # Before and after callbacks execute in the following order: # # 1. `before` # 2. `before_validation` # 3. _validations_ # 4. `after_validation` # 5. _the API call_ # 6. `after` # # Steps 4, 5 and 6 only happen if validation succeeds. module Callbacks extend ActiveSupport::Concern include Grape::DSL::Configuration module ClassMethods # Execute the given block before validation, coercion, or any endpoint # code is executed. def before(&block) namespace_stackable(:befores, block) end # Execute the given block after `before`, but prior to validation or # coercion. def before_validation(&block) namespace_stackable(:before_validations, block) end # Execute the given block after validations and coercions, but before # any endpoint code. def after_validation(&block) namespace_stackable(:after_validations, block) end # Execute the given block after the endpoint code has run. def after(&block) namespace_stackable(:afters, block) end end end end end grape-0.16.2/lib/grape/dsl/desc.rb0000644000004100000410000000637512706307016016634 0ustar www-datawww-datamodule Grape module DSL module Desc include Grape::DSL::Settings # Add a description to the next namespace or function. # @param description [String] descriptive string for this endpoint # or namespace # @param options [Hash] other properties you can set to describe the # endpoint or namespace. Optional. # @option options :detail [String] additional detail about this endpoint # @option options :params [Hash] param types and info. normally, you set # these via the `params` dsl method. # @option options :entity [Grape::Entity] the entity returned upon a # successful call to this action # @option options :http_codes [Array[Array]] possible HTTP codes this # endpoint may return, with their meanings, in a 2d array # @option options :named [String] a specific name to help find this route # @option options :headers [Hash] HTTP headers this method can accept # @yield a block yielding an instance context with methods mapping to # each of the above, except that :entity is also aliased as #success # and :http_codes is aliased as #failure. # # @example # # desc 'create a user' # post '/users' do # # ... # end # # desc 'find a user' do # detail 'locates the user from the given user ID' # failure [ [404, 'Couldn\'t find the given user' ] ] # success User::Entity # end # get '/user/:id' do # # ... # end # def desc(description, options = {}, &config_block) if block_given? config_class = desc_container config_class.configure do description description end config_class.configure(&config_block) unless options.empty? warn '[DEPRECATION] Passing a options hash and a block to `desc` is deprecated. Move all hash options to block.' end options = config_class.settings else options = options.merge(description: description) end namespace_setting :description, options route_setting :description, options end def description_field(field, value = nil) if value description = route_setting(:description) description ||= route_setting(:description, {}) description[field] = value else description = route_setting(:description) description[field] if description end end def unset_description_field(field) description = route_setting(:description) description.delete(field) if description end # Returns an object which configures itself via an instance-context DSL. def desc_container Module.new do include Grape::Util::StrictHashConfiguration.module( :description, :detail, :params, :entity, :http_codes, :named, :headers ) def config_context.success(*args) entity(*args) end def config_context.failure(*args) http_codes(*args) end end end end end end grape-0.16.2/lib/grape/dsl/validations.rb0000644000004100000410000000222612706307016020222 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL module Validations extend ActiveSupport::Concern include Grape::DSL::Configuration module ClassMethods # Clears all defined parameters and validations. def reset_validations! unset_namespace_stackable :declared_params unset_namespace_stackable :validations unset_namespace_stackable :params unset_description_field :params end # Opens a root-level ParamsScope, defining parameter coercions and # validations for the endpoint. # @yield instance context of the new scope def params(&block) Grape::Validations::ParamsScope.new(api: self, type: Hash, &block) end def document_attribute(names, opts) setting = description_field(:params) setting ||= description_field(:params, {}) Array(names).each do |name| setting[name[:full_name].to_s] ||= {} setting[name[:full_name].to_s].merge!(opts) namespace_stackable(:params, name[:full_name].to_s => opts) end end end end end end grape-0.16.2/lib/grape/dsl/settings.rb0000644000004100000410000001065212706307016017547 0ustar www-datawww-datarequire 'active_support/concern' module Grape module DSL # Keeps track of settings (impemented as key-value pairs, grouped by # types), in two contexts: top-level settings which apply globally no # matter where they're defined, and inheritable settings which apply only # in the current scope and scopes nested under it. module Settings extend ActiveSupport::Concern attr_accessor :inheritable_setting, :top_level_setting # Fetch our top-level settings, which apply to all endpoints in the API. def top_level_setting @top_level_setting ||= Grape::Util::InheritableSetting.new end # Fetch our current inheritable settings, which are inherited by # nested scopes but not shared across siblings. def inheritable_setting @inheritable_setting ||= Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from top_level_setting } end # @param type [Symbol] # @param key [Symbol] def unset(type, key) setting = inheritable_setting.send(type) setting.delete key end # @param type [Symbol] # @param key [Symbol] # @param value [Object] will be stored if the value is currently empty # @return either the old value, if it wasn't nil, or the given value def get_or_set(type, key, value) setting = inheritable_setting.send(type) if value.nil? setting[key] else setting[key] = value end end # @param key [Symbol] # @param value [Object] # @return (see #get_or_set) def global_setting(key, value = nil) get_or_set :global, key, value end # @param key [Symbol] def unset_global_setting(key) unset :global, key end # (see #global_setting) def route_setting(key, value = nil) get_or_set :route, key, value end # (see #unset_global_setting) def unset_route_setting(key) unset :route, key end # (see #global_setting) def namespace_setting(key, value = nil) get_or_set :namespace, key, value end # (see #unset_global_setting) def unset_namespace_setting(key) unset :namespace, key end # (see #global_setting) def namespace_inheritable(key, value = nil) get_or_set :namespace_inheritable, key, value end # (see #unset_global_setting) def unset_namespace_inheritable(key) unset :namespace_inheritable, key end # @param key [Symbol] def namespace_inheritable_to_nil(key) inheritable_setting.namespace_inheritable[key] = nil end # (see #global_setting) def namespace_stackable(key, value = nil) get_or_set :namespace_stackable, key, value end def namespace_stackable_with_hash(key) settings = get_or_set :namespace_stackable, key, nil return if settings.blank? settings.each_with_object({}) { |value, result| result.deep_merge!(value) } end # (see #unset_global_setting) def unset_namespace_stackable(key) unset :namespace_stackable, key end # (see #global_setting) def api_class_setting(key, value = nil) get_or_set :api_class, key, value end # (see #unset_global_setting) def unset_api_class_setting(key) unset :api_class, key end # Fork our inheritable settings to a new instance, copied from our # parent's, but separate so we won't modify it. Every call to this # method should have an answering call to #namespace_end. def namespace_start @inheritable_setting = Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from inheritable_setting } end # Set the inheritable settings pointer back up by one level. def namespace_end route_end @inheritable_setting = inheritable_setting.parent end # Stop defining settings for the current route and clear them for the # next, within a namespace. def route_end inheritable_setting.route_end end # Execute the block within a context where our inheritable settings are forked # to a new copy (see #namespace_start). def within_namespace(&_block) namespace_start result = yield if block_given? namespace_end reset_validations! result end end end end grape-0.16.2/lib/grape/serve_file/0000755000004100000410000000000012706307016016717 5ustar www-datawww-datagrape-0.16.2/lib/grape/serve_file/sendfile_response.rb0000644000004100000410000000065412706307016022760 0ustar www-datawww-datamodule Grape module ServeFile # Response should respond to to_path method # for using Rack::SendFile middleware class SendfileResponse < Rack::Response def respond_to?(method_name, include_all = false) if method_name == :to_path @body.respond_to?(:to_path, include_all) else super end end def to_path @body.to_path end end end end grape-0.16.2/lib/grape/serve_file/file_response.rb0000644000004100000410000000071312706307016022102 0ustar www-datawww-datamodule Grape module ServeFile # A simple class used to identify responses which represent files and do not # need to be formatted or pre-read by Rack::Response class FileResponse attr_reader :file # @param file [Object] def initialize(file) @file = file end # Equality provided mostly for tests. # # @return [Boolean] def ==(other) file == other.file end end end end grape-0.16.2/lib/grape/serve_file/file_body.rb0000644000004100000410000000111212706307016021173 0ustar www-datawww-datamodule Grape module ServeFile CHUNK_SIZE = 16_384 # Class helps send file through API class FileBody attr_reader :path # @param path [String] def initialize(path) @path = path end # Need for Rack::Sendfile middleware # # @return [String] def to_path path end def each File.open(path, 'rb') do |file| while (chunk = file.read(CHUNK_SIZE)) yield chunk end end end def ==(other) path == other.path end end end end grape-0.16.2/lib/grape/presenters/0000755000004100000410000000000012706307016016766 5ustar www-datawww-datagrape-0.16.2/lib/grape/presenters/presenter.rb0000644000004100000410000000022012706307016021314 0ustar www-datawww-datamodule Grape module Presenters class Presenter def self.represent(object, _options = {}) object end end end end grape-0.16.2/lib/grape/http/0000755000004100000410000000000012706307016015553 5ustar www-datawww-datagrape-0.16.2/lib/grape/http/headers.rb0000644000004100000410000000151312706307016017513 0ustar www-datawww-datamodule Grape module Http module Headers # https://github.com/rack/rack/blob/master/lib/rack.rb HTTP_VERSION = 'HTTP_VERSION'.freeze PATH_INFO = 'PATH_INFO'.freeze REQUEST_METHOD = 'REQUEST_METHOD'.freeze QUERY_STRING = 'QUERY_STRING'.freeze CONTENT_TYPE = 'Content-Type'.freeze GET = 'GET'.freeze POST = 'POST'.freeze PUT = 'PUT'.freeze PATCH = 'PATCH'.freeze DELETE = 'DELETE'.freeze HEAD = 'HEAD'.freeze OPTIONS = 'OPTIONS'.freeze HTTP_ACCEPT_VERSION = 'HTTP_ACCEPT_VERSION'.freeze X_CASCADE = 'X-Cascade'.freeze HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'.freeze HTTP_ACCEPT = 'HTTP_ACCEPT'.freeze FORMAT = 'format'.freeze end end end grape-0.16.2/lib/grape/validations.rb0000644000004100000410000000077012706307016017442 0ustar www-datawww-datamodule Grape # Registry to store and locate known Validators. module Validations class << self attr_accessor :validators end self.validators = {} # Register a new validator, so it can be used to validate parameters. # @param short_name [String] all lower-case, no spaces # @param klass [Class] the validator class. Should inherit from # Validations::Base. def self.register_validator(short_name, klass) validators[short_name] = klass end end end grape-0.16.2/lib/grape/util/0000755000004100000410000000000012706307016015551 5ustar www-datawww-datagrape-0.16.2/lib/grape/util/strict_hash_configuration.rb0000644000004100000410000000516612706307016023350 0ustar www-datawww-datamodule Grape module Util module StrictHashConfiguration extend ActiveSupport::Concern module DSL extend ActiveSupport::Concern module ClassMethods def settings config_context.to_hash end def configure(&block) config_context.instance_exec(&block) end end end class SettingsContainer def initialize @settings = {} @contexts = {} end def to_hash @settings.to_hash end end def self.config_class(*args) new_config_class = Class.new(SettingsContainer) args.each do |setting_name| if setting_name.respond_to? :values nested_settings_methods(setting_name, new_config_class) else simple_settings_methods(setting_name, new_config_class) end end new_config_class end def self.simple_settings_methods(setting_name, new_config_class) setting_name_sym = setting_name.to_sym new_config_class.class_eval do define_method setting_name do |new_value| @settings[setting_name_sym] = new_value end end end def self.nested_settings_methods(setting_name, new_config_class) new_config_class.class_eval do setting_name.each_pair do |key, value| define_method "#{key}_context" do @contexts[key] ||= Grape::Util::StrictHashConfiguration.config_class(*value).new end define_method key do |&block| send("#{key}_context").instance_exec(&block) end end define_method 'to_hash' do merge_hash = {} setting_name.each_key { |k| merge_hash[k] = send("#{k}_context").to_hash } @settings.to_hash.merge( merge_hash ) end end end def self.module(*args) new_module = Module.new do extend ActiveSupport::Concern include DSL end new_module.tap do |mod| class_mod = create_class_mod(args) mod.const_set(:ClassMethods, class_mod) end end def self.create_class_mod(args) new_module = Module.new do def config_context @config_context ||= config_class.new end end new_module.tap do |class_mod| new_config_class = config_class(*args) class_mod.send(:define_method, :config_class) do @config_class ||= new_config_class end end end end end end grape-0.16.2/lib/grape/util/stackable_values.rb0000644000004100000410000000234412706307016021411 0ustar www-datawww-datamodule Grape module Util class StackableValues attr_accessor :inherited_values attr_reader :new_values attr_reader :froozen_values def initialize(inherited_values = {}) @inherited_values = inherited_values @new_values = {} @froozen_values = {} end def [](name) return @froozen_values[name] if @froozen_values.key? name value = [@inherited_values[name], @new_values[name]] value.compact! value.flatten!(1) value end def []=(name, value) fail if @froozen_values.key? name @new_values[name] ||= [] @new_values[name].push value end def delete(key) new_values.delete key end attr_writer :new_values def keys (@new_values.keys + @inherited_values.keys).sort.uniq end def to_hash keys.each_with_object({}) do |key, result| result[key] = self[key] end end def freeze_value(key) @froozen_values[key] = self[key].freeze end def initialize_copy(other) super self.inherited_values = other.inherited_values self.new_values = other.new_values.dup end end end end grape-0.16.2/lib/grape/util/content_types.rb0000644000004100000410000000120312706307016020770 0ustar www-datawww-datamodule Grape module ContentTypes # Content types are listed in order of preference. CONTENT_TYPES = { xml: 'application/xml', serializable_hash: 'application/json', json: 'application/json', binary: 'application/octet-stream', txt: 'text/plain' } def self.content_types_for_settings(settings) return if settings.blank? settings.each_with_object({}) { |value, result| result.merge!(value) } end def self.content_types_for(from_settings) if from_settings.present? from_settings else Grape::ContentTypes::CONTENT_TYPES end end end end grape-0.16.2/lib/grape/util/inheritable_values.rb0000644000004100000410000000162312706307016021745 0ustar www-datawww-datamodule Grape module Util class InheritableValues attr_accessor :inherited_values attr_accessor :new_values def initialize(inherited_values = {}) self.inherited_values = inherited_values self.new_values = {} end def [](name) values[name] end def []=(name, value) new_values[name] = value end def delete(key) new_values.delete key end def merge(new_hash) values.merge(new_hash) end def keys (new_values.keys + inherited_values.keys).sort.uniq end def to_hash values.clone end def initialize_copy(other) super self.inherited_values = other.inherited_values self.new_values = other.new_values.dup end protected def values @inherited_values.merge(@new_values) end end end end grape-0.16.2/lib/grape/util/registrable.rb0000644000004100000410000000040412706307016020377 0ustar www-datawww-datamodule Grape module Util module Registrable def default_elements @default_elements ||= {} end def register(format, element) default_elements[format] = element unless default_elements[format] end end end end grape-0.16.2/lib/grape/util/env.rb0000644000004100000410000000154112706307016016667 0ustar www-datawww-datamodule Grape module Env API_VERSION = 'api.version'.freeze API_ENDPOINT = 'api.endpoint'.freeze API_REQUEST_INPUT = 'api.request.input'.freeze API_REQUEST_BODY = 'api.request.body'.freeze API_TYPE = 'api.type'.freeze API_SUBTYPE = 'api.subtype'.freeze API_VENDOR = 'api.vendor'.freeze API_FORMAT = 'api.format'.freeze RACK_INPUT = 'rack.input'.freeze RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'.freeze RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'.freeze RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'.freeze GRAPE_REQUEST = 'grape.request'.freeze GRAPE_REQUEST_HEADERS = 'grape.request.headers'.freeze GRAPE_REQUEST_PARAMS = 'grape.request.params'.freeze GRAPE_ROUTING_ARGS = 'grape.routing_args'.freeze GRAPE_METHOD_NOT_ALLOWED = 'grape.method_not_allowed'.freeze end end grape-0.16.2/lib/grape/util/inheritable_setting.rb0000644000004100000410000000612612706307016022126 0ustar www-datawww-datamodule Grape module Util # A branchable, inheritable settings object which can store both stackable # and inheritable values (see InheritableValues and StackableValues). class InheritableSetting attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable attr_accessor :parent, :point_in_time_copies # Retrieve global settings. def self.global @global ||= {} end # Clear all global settings. # @api private # @note only for testing def self.reset_global! @global = {} end # Instantiate a new settings instance, with blank values. The fresh # instance can then be set to inherit from an existing instance (see # #inherit_from). def initialize self.route = {} self.api_class = {} self.namespace = InheritableValues.new # only inheritable from a parent when # used with a mount, or should every API::Class be a separate namespace by default? self.namespace_inheritable = InheritableValues.new self.namespace_stackable = StackableValues.new self.point_in_time_copies = [] self.parent = nil end # Return the class-level global properties. def global self.class.global end # Set our inherited values to the given parent's current values. Also, # update the inherited values on any settings instances which were forked # from us. # @param parent [InheritableSetting] def inherit_from(parent) return if parent.nil? self.parent = parent namespace_inheritable.inherited_values = parent.namespace_inheritable namespace_stackable.inherited_values = parent.namespace_stackable self.route = parent.route.merge(route) point_in_time_copies.map { |cloned_one| cloned_one.inherit_from parent } end # Create a point-in-time copy of this settings instance, with clones of # all our values. Note that, should this instance's parent be set or # changed via #inherit_from, it will copy that inheritence to any copies # which were made. def point_in_time_copy self.class.new.tap do |new_setting| point_in_time_copies << new_setting new_setting.point_in_time_copies = [] new_setting.namespace = namespace.clone new_setting.namespace_inheritable = namespace_inheritable.clone new_setting.namespace_stackable = namespace_stackable.clone new_setting.route = route.clone new_setting.api_class = api_class new_setting.inherit_from(parent) end end # Resets the instance store of per-route settings. # @api private def route_end @route = {} end # Return a serializable hash of our values. def to_hash { global: global.clone, route: route.clone, namespace: namespace.to_hash, namespace_inheritable: namespace_inheritable.to_hash, namespace_stackable: namespace_stackable.to_hash } end end end end grape-0.16.2/lib/grape/error_formatter/0000755000004100000410000000000012706307016020010 5ustar www-datawww-datagrape-0.16.2/lib/grape/error_formatter/xml.rb0000644000004100000410000000105012706307016021131 0ustar www-datawww-datamodule Grape module ErrorFormatter module Xml extend Base class << self def call(message, backtrace, options = {}, env = nil) message = present(message, env) result = message.is_a?(Hash) ? message : { message: message } if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty? result = result.merge(backtrace: backtrace) end result.respond_to?(:to_xml) ? result.to_xml(root: :error) : result.to_s end end end end end grape-0.16.2/lib/grape/error_formatter/json.rb0000644000004100000410000000123512706307016021307 0ustar www-datawww-datamodule Grape module ErrorFormatter module Json extend Base class << self def call(message, backtrace, options = {}, env = nil) result = wrap_message(present(message, env)) if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty? result = result.merge(backtrace: backtrace) end MultiJson.dump(result) end private def wrap_message(message) if message.is_a?(Exceptions::ValidationErrors) || message.is_a?(Hash) message else { error: message } end end end end end end grape-0.16.2/lib/grape/error_formatter/txt.rb0000644000004100000410000000077612706307016021166 0ustar www-datawww-datamodule Grape module ErrorFormatter module Txt extend Base class << self def call(message, backtrace, options = {}, env = nil) message = present(message, env) result = message.is_a?(Hash) ? MultiJson.dump(message) : message if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty? result += "\r\n " result += backtrace.join("\r\n ") end result end end end end end grape-0.16.2/lib/grape/error_formatter/base.rb0000644000004100000410000000247312706307016021255 0ustar www-datawww-datamodule Grape module ErrorFormatter module Base def present(message, env) present_options = {} presented_message = message if presented_message.is_a?(Hash) presented_message = presented_message.dup present_options[:with] = presented_message.delete(:with) end presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(presented_message, present_options) unless presenter || env[Grape::Env::GRAPE_ROUTING_ARGS].nil? # env['api.endpoint'].route does not work when the error occurs within a middleware # the Endpoint does not have a valid env at this moment http_codes = env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info].http_codes || [] found_code = http_codes.find do |http_code| (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent) end if env[Grape::Env::API_ENDPOINT].request presenter = found_code[2] if found_code end if presenter embeds = { env: env } embeds[:version] = env[Grape::Env::API_VERSION] if env[Grape::Env::API_VERSION] presented_message = presenter.represent(presented_message, embeds).serializable_hash end presented_message end end end end grape-0.16.2/lib/grape/cookies.rb0000644000004100000410000000152112706307016016554 0ustar www-datawww-datamodule Grape class Cookies def initialize @cookies = {} @send_cookies = {} end def read(request) request.cookies.each do |name, value| @cookies[name.to_s] = value end end def write(header) @cookies.select { |key, _value| @send_cookies[key] == true }.each do |name, value| cookie_value = value.is_a?(Hash) ? value : { value: value } Rack::Utils.set_cookie_header! header, name, cookie_value end end def [](name) @cookies[name.to_s] end def []=(name, value) @cookies[name.to_s] = value @send_cookies[name.to_s] = true end def each(&block) @cookies.each(&block) end def delete(name, opts = {}) options = opts.merge(value: 'deleted', expires: Time.at(0)) self.[]=(name, options) end end end grape-0.16.2/lib/grape/locale/0000755000004100000410000000000012706307016016033 5ustar www-datawww-datagrape-0.16.2/lib/grape/locale/en.yml0000644000004100000410000000460112706307016017161 0ustar www-datawww-dataen: grape: errors: format: ! '%{attributes} %{message}' messages: coerce: 'is invalid' presence: 'is missing' regexp: 'is invalid' blank: 'is empty' values: 'does not have a valid value' missing_vendor_option: problem: 'missing :vendor option.' summary: 'when version using header, you must specify :vendor option. ' resolution: "eg: version 'v1', using: :header, vendor: 'twitter'" missing_mime_type: problem: 'missing mime type for %{new_format}' resolution: "you can choose existing mime type from Grape::ContentTypes::CONTENT_TYPES or add your own with content_type :%{new_format}, 'application/%{new_format}' " invalid_with_option_for_represent: problem: 'You must specify an entity class in the :with option.' resolution: 'eg: represent User, :with => Entity::User' missing_option: 'You must specify :%{option} options.' invalid_formatter: 'cannot convert %{klass} to %{to_format}' invalid_versioner_option: problem: 'Unknown :using for versioner: %{strategy}' resolution: 'available strategy for :using is :path, :header, :param' unknown_validator: 'unknown validator: %{validator_type}' unknown_options: 'unknown options: %{options}' unknown_parameter: 'unknown parameter: %{param}' incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}' mutual_exclusion: 'are mutually exclusive' at_least_one: 'are missing, at least one parameter must be provided' exactly_one: 'are missing, exactly one parameter must be provided' all_or_none: 'provide all or none of parameters' missing_group_type: 'group type is required' unsupported_group_type: 'group type must be Array, Hash, JSON or Array[JSON]' invalid_message_body: problem: "message body does not match declared format" resolution: "when specifying %{body_format} as content-type, you must pass valid %{body_format} in the request's 'body' " invalid_accept_header: problem: 'Invalid accept header' resolution: '%{message}' invalid_version_header: problem: 'Invalid version header' resolution: '%{message}' grape-0.16.2/lib/grape/error_formatter.rb0000644000004100000410000000152612706307016020341 0ustar www-datawww-datamodule Grape module ErrorFormatter extend Util::Registrable class << self def builtin_formatters @builtin_formatters ||= { serializable_hash: Grape::ErrorFormatter::Json, json: Grape::ErrorFormatter::Json, jsonapi: Grape::ErrorFormatter::Json, txt: Grape::ErrorFormatter::Txt, xml: Grape::ErrorFormatter::Xml } end def formatters(options) builtin_formatters.merge(default_elements).merge(options[:error_formatters] || {}) end def formatter_for(api_format, options = {}) spec = formatters(options)[api_format] case spec when nil options[:default_error_formatter] || Grape::ErrorFormatter::Txt when Symbol method(spec) else spec end end end end end grape-0.16.2/lib/grape.rb0000644000004100000410000001105612706307016015124 0ustar www-datawww-datarequire 'logger' require 'rack' require 'rack/builder' require 'rack/accept' require 'rack/auth/basic' require 'rack/auth/digest/md5' require 'hashie' require 'set' require 'active_support/version' require 'active_support/core_ext/hash/indifferent_access' require 'active_support/core_ext/object/blank' require 'active_support/core_ext/array/extract_options' require 'active_support/core_ext/array/wrap' require 'active_support/core_ext/hash/deep_merge' require 'active_support/core_ext/hash/reverse_merge' require 'active_support/core_ext/hash/except' require 'active_support/core_ext/hash/conversions' require 'active_support/dependencies/autoload' require 'active_support/notifications' require 'multi_json' require 'multi_xml' require 'i18n' require 'thread' require 'virtus' I18n.load_path << File.expand_path('../grape/locale/en.yml', __FILE__) module Grape extend ActiveSupport::Autoload eager_autoload do autoload :API autoload :Endpoint autoload :Router autoload :Namespace autoload :Path autoload :Cookies autoload :Validations autoload :ErrorFormatter autoload :Formatter autoload :Parser autoload :Request autoload :Env, 'grape/util/env' end module Http extend ActiveSupport::Autoload eager_autoload do autoload :Headers end end module Exceptions extend ActiveSupport::Autoload autoload :Base autoload :Validation autoload :ValidationErrors autoload :MissingVendorOption autoload :MissingMimeType autoload :MissingOption autoload :InvalidFormatter autoload :InvalidVersionerOption autoload :UnknownValidator autoload :UnknownOptions autoload :UnknownParameter autoload :InvalidWithOptionForRepresent autoload :IncompatibleOptionValues autoload :MissingGroupTypeError, 'grape/exceptions/missing_group_type' autoload :UnsupportedGroupTypeError, 'grape/exceptions/unsupported_group_type' autoload :InvalidMessageBody autoload :InvalidAcceptHeader autoload :InvalidVersionHeader autoload :MethodNotAllowed end module Middleware extend ActiveSupport::Autoload autoload :Base autoload :Versioner autoload :Formatter autoload :Error autoload :Globals module Auth extend ActiveSupport::Autoload autoload :Base autoload :DSL autoload :StrategyInfo autoload :Strategies end module Versioner extend ActiveSupport::Autoload autoload :Path autoload :Header autoload :Param autoload :AcceptVersionHeader end end module Util extend ActiveSupport::Autoload autoload :InheritableValues autoload :StackableValues autoload :InheritableSetting autoload :StrictHashConfiguration autoload :Registrable end module ErrorFormatter extend ActiveSupport::Autoload autoload :Base autoload :Json autoload :Txt autoload :Xml end module Formatter extend ActiveSupport::Autoload autoload :Json autoload :SerializableHash autoload :Txt autoload :Xml end module Parser extend ActiveSupport::Autoload autoload :Json autoload :Xml end module DSL extend ActiveSupport::Autoload eager_autoload do autoload :API autoload :Callbacks autoload :Settings autoload :Configuration autoload :InsideRoute autoload :Helpers autoload :Middleware autoload :Parameters autoload :RequestResponse autoload :Routing autoload :Validations autoload :Logger autoload :Desc end end class API extend ActiveSupport::Autoload autoload :Helpers end module Presenters extend ActiveSupport::Autoload autoload :Presenter end module ServeFile extend ActiveSupport::Autoload autoload :FileResponse autoload :FileBody autoload :SendfileResponse end end require 'grape/util/content_types' require 'grape/validations/validators/base' require 'grape/validations/attributes_iterator' require 'grape/validations/validators/allow_blank' require 'grape/validations/validators/at_least_one_of' require 'grape/validations/validators/coerce' require 'grape/validations/validators/default' require 'grape/validations/validators/exactly_one_of' require 'grape/validations/validators/mutual_exclusion' require 'grape/validations/validators/presence' require 'grape/validations/validators/regexp' require 'grape/validations/validators/values' require 'grape/validations/params_scope' require 'grape/validations/validators/all_or_none' require 'grape/validations/types' require 'grape/version' grape-0.16.2/gemfiles/0000755000004100000410000000000012706307016014523 5ustar www-datawww-datagrape-0.16.2/gemfiles/rack_1.5.2.gemfile0000644000004100000410000000031212706307016017514 0ustar www-datawww-data# This file was generated by Appraisal source 'https://rubygems.org' gem 'rack', '1.5.2' group :development, :test do gem 'guard' gem 'guard-rspec' gem 'guard-rubocop' end gemspec path: '../' grape-0.16.2/gemfiles/rails_3.gemfile0000644000004100000410000000034712706307016017415 0ustar www-datawww-data# This file was generated by Appraisal source 'https://rubygems.org' gem 'rails', '3.2.22' gem 'rack-cache', '<= 1.2' group :development, :test do gem 'guard' gem 'guard-rspec' gem 'guard-rubocop' end gemspec path: '../' grape-0.16.2/gemfiles/rails_3.gemfile.lock0000644000004100000410000001164112706307016020343 0ustar www-datawww-dataPATH remote: ../ specs: grape (0.14.1) activesupport builder hashie (>= 2.1.0) multi_json (>= 1.3.2) multi_xml (>= 0.5.2) rack (>= 1.3.0) rack-accept rack-mount virtus (>= 1.0.0) GEM remote: https://rubygems.org/ specs: actionmailer (3.2.22) actionpack (= 3.2.22) mail (~> 2.5.4) actionpack (3.2.22) activemodel (= 3.2.22) activesupport (= 3.2.22) builder (~> 3.0.0) erubis (~> 2.7.0) journey (~> 1.0.4) rack (~> 1.4.5) rack-cache (~> 1.2) rack-test (~> 0.6.1) sprockets (~> 2.2.1) activemodel (3.2.22) activesupport (= 3.2.22) builder (~> 3.0.0) activerecord (3.2.22) activemodel (= 3.2.22) activesupport (= 3.2.22) arel (~> 3.0.2) tzinfo (~> 0.3.29) activeresource (3.2.22) activemodel (= 3.2.22) activesupport (= 3.2.22) activesupport (3.2.22) i18n (~> 0.6, >= 0.6.4) multi_json (~> 1.0) appraisal (2.1.0) bundler rake thor (>= 0.14.0) arel (3.0.3) ast (2.2.0) astrolabe (1.3.1) parser (~> 2.2) axiom-types (0.1.1) descendants_tracker (~> 0.0.4) ice_nine (~> 0.11.0) thread_safe (~> 0.3, >= 0.3.1) benchmark-ips (2.3.0) builder (3.0.4) coderay (1.1.0) coercible (1.0.0) descendants_tracker (~> 0.0.1) cookiejar (0.3.2) descendants_tracker (0.0.4) thread_safe (~> 0.3, >= 0.3.1) diff-lcs (1.2.5) equalizer (0.0.11) erubis (2.7.0) ffi (1.9.10) formatador (0.2.5) git-version-bump (0.15.1) grape-entity (0.5.0) activesupport multi_json (>= 1.3.2) guard (2.13.0) formatador (>= 0.2.4) listen (>= 2.7, <= 4.0) lumberjack (~> 1.0) nenv (~> 0.1) notiffany (~> 0.0) pry (>= 0.9.12) shellany (~> 0.0) thor (>= 0.18.1) guard-compat (1.2.1) guard-rspec (4.6.4) guard (~> 2.1) guard-compat (~> 1.1) rspec (>= 2.99.0, < 4.0) guard-rubocop (1.2.0) guard (~> 2.0) rubocop (~> 0.20) hashie (3.4.3) hike (1.2.3) i18n (0.7.0) ice_nine (0.11.1) journey (1.0.4) json (1.8.3) listen (3.0.5) rb-fsevent (>= 0.9.3) rb-inotify (>= 0.9) lumberjack (1.0.10) mail (2.5.4) mime-types (~> 1.16) treetop (~> 1.4.8) maruku (0.7.2) method_source (0.8.2) mime-types (1.25.1) multi_json (1.11.2) multi_xml (0.5.5) nenv (0.2.0) notiffany (0.0.8) nenv (~> 0.1) shellany (~> 0.0) parser (2.2.3.0) ast (>= 1.1, < 3.0) polyglot (0.3.5) powerpack (0.1.1) pry (0.10.3) coderay (~> 1.1.0) method_source (~> 0.8.1) slop (~> 3.4) rack (1.4.7) rack-accept (0.4.5) rack (>= 0.4) rack-cache (1.2) rack (>= 0.4) rack-contrib (1.4.0) git-version-bump (~> 0.15) rack (~> 1.4) rack-mount (0.8.3) rack (>= 1.0.0) rack-ssl (1.3.4) rack rack-test (0.6.3) rack (>= 1.0) rails (3.2.22) actionmailer (= 3.2.22) actionpack (= 3.2.22) activerecord (= 3.2.22) activeresource (= 3.2.22) activesupport (= 3.2.22) bundler (~> 1.0) railties (= 3.2.22) railties (3.2.22) actionpack (= 3.2.22) activesupport (= 3.2.22) rack-ssl (~> 1.3.2) rake (>= 0.8.7) rdoc (~> 3.4) thor (>= 0.14.6, < 2.0) rainbow (2.0.0) rake (10.4.2) rb-fsevent (0.9.7) rb-inotify (0.9.5) ffi (>= 0.5.0) rdoc (3.12.2) json (~> 1.4) rspec (3.4.0) rspec-core (~> 3.4.0) rspec-expectations (~> 3.4.0) rspec-mocks (~> 3.4.0) rspec-core (3.4.1) rspec-support (~> 3.4.0) rspec-expectations (3.4.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.4.0) rspec-mocks (3.4.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.4.0) rspec-support (3.4.1) rubocop (0.35.1) astrolabe (~> 1.3) parser (>= 2.2.3.0, < 3.0) powerpack (~> 0.1) rainbow (>= 1.99.1, < 3.0) ruby-progressbar (~> 1.7) tins (<= 1.6.0) ruby-progressbar (1.7.5) shellany (0.0.1) slop (3.6.0) sprockets (2.2.3) hike (~> 1.2) multi_json (~> 1.0) rack (~> 1.0) tilt (~> 1.1, != 1.3.0) thor (0.19.1) thread_safe (0.3.5) tilt (1.4.1) tins (1.6.0) treetop (1.4.15) polyglot polyglot (>= 0.3.1) tzinfo (0.3.46) virtus (1.0.5) axiom-types (~> 0.1) coercible (~> 1.0) descendants_tracker (~> 0.0, >= 0.0.3) equalizer (~> 0.0, >= 0.0.9) yard (0.8.7.6) PLATFORMS ruby DEPENDENCIES appraisal benchmark-ips bundler cookiejar grape! grape-entity (>= 0.4.4) guard guard-rspec guard-rubocop maruku mime-types (< 3.0) rack-cache (<= 1.2) rack-contrib rack-test rails (= 3.2.22) rake rspec (~> 3.0) rubocop (= 0.35.1) yard BUNDLED WITH 1.11.2 grape-0.16.2/gemfiles/rails_4.gemfile0000644000004100000410000000031312706307016017407 0ustar www-datawww-data# This file was generated by Appraisal source 'https://rubygems.org' gem 'rails', '4.1.6' group :development, :test do gem 'guard' gem 'guard-rspec' gem 'guard-rubocop' end gemspec path: '../' grape-0.16.2/grape.png0000644000004100000410000001026012706307016014533 0ustar www-datawww-data‰PNG  IHDRX{1#˜ltEXtSoftwareAdobe ImageReadyqÉe<RIDATxÚì]rÓÊÇ'ÔyÇw˜D ˆXf(+ÀþÓÓ3Óc €@œÅÎÀêÙßçôaSnÓ’ÓÑÔ·ŸÎPÌ«ö£ùµÖ¦Ž¿W[͸ •ß¿"TÉ ¾È8‘!·±ÚS‘ö„Ú'‘Äõ3&W@h ²j­½=9µ/õÕ~¬QÇ€ˆ,lª|‹lPeq-P·€Dð*²ÁÖ¾Ä;ˆ+ Q‘=Ÿ¬ÀÚÌ?5¿´ E6S¶`I\¨C@¢ä¼³i’ × uÔß½ , °^©³Ò~`ˆƒ¹ÒsÔ?³g{@ ȈË ÂóúöÓֵ͔0×ö…¯Ð®,~¯ˆãSžæ—?¡:ÛNY`I\sÍÑpÒâûË~|´BÛÙÏ*…<=I¸¼6W€@h¯L".Å”¶FSLY?’XX¯Z,œ0XðÄ_(w^¾|ùÌüû&†îçÏŸ·'ø®´&óñžöÙ‡Ž*níoÜL°¬(€ÈbJíâ@œd[†À¦Û_›ß§>2óÀæfûÿèƒ|A %ÛH¿Oô}ßšûk}{þ:àóƒQ_n¹9òš .Ë»ÎΩíS*â+h}Û¨í;üŠ”ß|P•·“gˆ.VÕr[s³¹ïlk"ûYÙ†ùqÏó?˜ñ¤sû¬ëåÑŒü~¹//‚÷]!ª$<…q?mÓ r>xó{Õxsl§w-oÅvAe²µÏ©¹>n=·ã þÍ•¿©¾/û»«Wì³Z.s:|°ÇwÆθG£ÆYÚçý—§)[èÎïKÂjÓW~ÖFA\*W¸Ž~=D9½Sj =ÊÿgmuaµéÂ…Ñ9±DõYq{~ ¥€ÀJâ£n‘¡M­QRÇfA¬…•žó™Å§ü½P}ð\V_yÐÐdÔŠuúÍø½oÉBû#Ôྸ’…Ùz´º 7Ê·‰¼ïÓuãZn‰ïZÉ"èK\}$Ú [È3‘U 2ÏS4 °iŠkc„YÜ$â.h\“A¹e‰Te¡-²Äu·m|æóëLÄap¨ ²ØÄõOƒŒüΟÅ5µØ¿…¢»`Ãå16ÿ÷EL ²ؽÓä*‚Hd±¦ÔìëÓøíå6Æ] á\GÌÿëƒe‘H¹Ï^d!°; 9âô6–8iYÏšåÖxªÛ)S=6H°˜­Ë÷&å3¾Á>X}KnJ¥³Œœ‡Ž§³Í¾ƒ“c…£eFÓûË ×Õ‚ËéÍö{n‰º'ß”¯°`a½jXƒÔ‘—V,Îú4ˆÔB0ÆWÚXÿܦ/‡NcÑ 'ÚÜoÓ%—£4JÒÂó¢–è|§î—Ü&¨mlcõÀö-qݲxçTNä_<»qÝ vúÖkîعV‡Ná°xPºXÙÌ‹}MÂ:æ TŽ¶üV\Þ— ‰…öI)§âÐ1hn”¾Û¼¯ƒ°‹!ðj§ý~phOô¼Í¡£º;ù/Yˆ%ù'?rãHð©[°ù:»‹ÕjÍ‹c8’HÐÿOt:wH@jîˆ×gÎKß¡+®;^ú»Ú{˳•ïGæ¬ñ7Ž®Ž|hÅŽêJê5££ÒÇŠ•=ç_Rþ 3 œª^…°`%º h½>s°(jžºJ„âÒþö„Û>–†-›CâqÍ@$bẅ¨vVMmÙðKP÷W\vÒ‚Êüz`Œµæ·œ÷‡¶»ˆÅãزb¥îÕAØ«KWà¦.°·5îÛa ãî—óÑ0iúþêËLÚ]}Ñ]åT¸H©Úl!ÌûBÛ•X±A ‡QTóçÛE°qèä©O Ö®#1?¥iSoÙ;}—ìV¡Üb‡É+•B$JXZ°{Í{cÇÖJØLWMª3¶?ek Cµ8ÞÖfòƒx…¼OGRáVˆ6~N*VìØic¿ò<69y_åÖ(’âFú¬\Øv+Ųä}å#ZØ¡ÁD:€òìÛ/>XW—Fd;“CÄ"íüÕ&þé›ÑVYÄ@×eÄrÒŽ] ß'Î ÔÚ.ïêèù ¼‡>_; èÕ±ÜõòUU –TߦŽâÚ¼Q6s¨8톓ÎÄ?»~̀؇SŒ9ÍT­+žj7¶;vq«ñ°À$)§ç¶&ΡŒ6äª<û½©Á/ŸK3 |Öý¬ ýç¡ÚÕ•K+²¡gÇÉìÝ# ßêÜl•æƒ”¡¬Î`æÖîhP 6°³ÈÖì.6 ÇXUzÙ:°K õÎÂU·Ê‘ÉV'VG[ÏõŸ¡xYÚ¹ð·`õÁÓ½Šm,%!!¿mê­ ²Þ;ïcƒ–°ž›û½±`õ‹(~u×µ‘osEÌp…4Z—dAižœ@ƒ‹GtŠe…ƒéÔZ·óÔ¦oÜF½[®)ì:9ñƒ aÆB8Ùé!ïM-Zzs ŒÜ­ÖÖDpY¥p›,ŸjÓ2_BË‚uZ¸a˵ðœÇ†]s÷?ÒP‡‰³4ó"ÈÎ 6ÚêXåë샭o?ñ‘óá2E\Ñ1[Ú»°’GjäkôpL4Š벯“}®Z–kÇõÑ'üÚÄ@,'úìaw‰”e¨|T e[±H·c׋T¹x‹%ÚÔ{áøR%/|¥32ã÷Õšb¿6ÓÄõxmÃm¥I BV4 ü„â(¼Ÿ‘kàÂÑ-pwØe^}ÍÌ5Ÿœh„VY32Ä¡é4E;“ÛÎÄÖkîPîîñzb¯Mì¹IÌ’"R¸X­´wÖ5^|°l}æÓ€Þ)µ;‘Ÿ 6$—æíc£Sµ'à&JÊE06ÆmÑjÉ–l˦Ýqô[ÏVfâ1úNâPN1CÕ6CAÒ¥S]Ç«oêòkQÓñÕæÝi¥œß¡ôµÙ Öü¹I£â3~Né3÷¡‹W—Ó_…Ë*6[yJ3Ÿ±–ìà^±Âáw7;o…uñMR4‹°é‡à¶|¯ØD)ÍüBƹ ™š.¤ YŠÖY²?Žt½5÷Ñœ¤4ÃcÚŽW“Ý‘ÛŠ]/Ç«KÔ´ÍÜ: \ƒ†Ê÷ÅZÙy'—ÔM ™ò“åDß+Žñűp•&í0ˆ”·†¯°nö >™¹¬aì¶Ýö·WF~r’žY²‹«Ý“ÿ¥¹¿M< S>!°óÙ﶑¹úc¥âZ™i…á«Ü‡˜³åÔòs¶æÿýº½åfZ‹Kã7²Øæía…qP•y,ïÂÌì¿Eö½íø‹À Â5 Y,uµº}vèS£3,f‘Û€g`U‚yßL0î„ ðÁîo¬—j1ÅÆçèû‹ÅTÅœ²GóRjÛÎ)‚vœÈÆßÂWßi¦¼ªº1éÄ= h 7ÎúØøÃGÅÕÌü !ìãAzQz^Æŧ\>dQÅ8Uµ5²ÅÈ¥Â; ,`ÅØAx`D×ĦC`‘[›^+m*nt¯Nå4 [V>-ý}w)¬ •hR¬Ä-ÂWÂ<öÆAŒù\_Ì]\!°ãì5w¬þTV `ûˆ¥Z±-èû§èìçÎœ{îÌTÎå ãJWÌs¥wöéBº»CÊõZ"þ~{sˆ°·ZßC1~ƒ]²iñwNšH`¶ • ­bÓ;¬nŒÛ~ ÛfhõÓß¼ït촿Ъ;Xl0)yg”=¹½~l?ôøΘÛ)-ì´X:ÏÍNç,|úÎ\p’ ¹?n\?0Õ,Mäˆd,ú—öK¯ÕÈ<õþäÊç즯®Ÿ×æ~k ´üÚA¾oÑ}!°©3Vˆ¶{:z'e¸3ÓbÐöyfƒ©y~Àê?»c;lJ癦ÆïùØi/^ÙÎàÙª ÏÆÃíÄÇäõÏ ŒóºÔK¶g°ïÌ}€ïv®{ZOJ`é>ó@7ËF‡ãsŽµ`Û)¼‹í5'“Ê @l¯&”×ÛAýÌvF87 67ú~Î}âvadÛ°VŠÛ¬ á pX?¢“ò.‚Pº]®îÖø§Xtg¿&‘Ø) ln êk )¬4žæ3…,”ÂéL®À^qmà"8RÄl‘©_šÆó͵®4B‹´–^zÈÖëk¡¥^c7˜±€î[&¡°Ÿ¡n•uaiÞ~t¦Giè½þÒÃÑ"ËÁ—¥ÁR6èj`¦ø8º>DÕõ6û[eÙMpeÜn–þœ®ê0ò ïl“À1¨½sÉ»k3|kÍúƤU§t° ‰ ßÇ>]:æs~€ª)ºzñJÚ’¥(I|í†ë@à3ˆô:ÆÆtfÀÖxp½ÙEÀ QÍ yeÒ½ø°âPy}6>6…ܦU˜Äomå…ª<Á|V®wØÒZqõrÂ0˜À’/6QñÚÙã?ôÞJˆ+þÄÕx\ zÐÀŠìÍ„D–ü¨17ó“Àçs¼ê€âê3æIð“\,²¾÷²©¸ lzÁšíK?Çv,üÍ ­½ðP*ÊQYrØÔ_Ã’ô‘O¾Éà¹ùíCö9(ˆÓ¬%¬V¼/´S`éËçºKÔ£²¼»àÎJ[=û›¢Z-MäÊ-F¸âÃ+s°Ø…ÆÜ•Æö«°P¹—(†ÉÑ êêz˳砜¡¾ÜàX®4(ô{_÷,nv+‚ iþ'À¬¶Mû9UIEND®B`‚grape-0.16.2/pkg/0000755000004100000410000000000012706307016013511 5ustar www-datawww-datagrape-0.16.2/pkg/patch.diff0000644000004100000410000000133512706307016015444 0ustar www-datawww-datadiff --git lib/grape/router/route.rb lib/grape/router/route.rb index 643960d..1074c01 100644 --- lib/grape/router/route.rb +++ lib/grape/router/route.rb @@ -20,7 +20,9 @@ module Grape :entity, :details, :requirements, - :request_method + :request_method, + :hidden, + :params ].freeze attr_accessor :pattern, :translator, :app, :index, :regexp @@ -42,7 +44,7 @@ module Grape if match method_name = match.captures.last.to_sym warn_route_methods(method_name, caller(1).shift) - @options[method_name] + respond_to?(method_name) ? send(method_name) : @options[method_name] else super end grape-0.16.2/pkg/grape-0.16.1.gem0000644000004100000410000053300012706307016016023 0ustar www-datawww-datametadata.gz0000444000000000000000000000446112700012422013431 0ustar00wheelwheel00000000000000‹Wí\_Û6÷§ÐõeŸ,{ÿ´ÀmqÛd‘.n‹Mzw8´DËŒ)QGR»ëÚÏ~CR–e‹’¨&[g m‚Äâü†‡Ã™½Óé4ø›(–Û_~ ‘Z¼!ébñ.']Ñ+ʳI†S²s2y BBÛÂÁôOKšAš‡çß„ç“œaµâ"]ši‚ µæB.&Óà'­1aÁŒÐd­)\ÿTÀ€“%Íb*ü?‰ˆP°zý÷&1V€¸˜Ÿ3_MçÁ|¾0Ãùî'ø×$&9Éb’E”˜Ñš2¿Þ!¶ ¶§ÀÑJ1R’)×dï÷dÀa(Ý2…?_}ÿÝWæA?viÌþTz;/Ã94«m-D‘)šhÈ„,¡y…™${m£N$²§ŽÓB*"Rœeçÿlºþýû?$ø<¼ /O¤ëOy€=Oq‘\Ú¬Ïæg/˨µÀžjÆ‘¢DyÎŨègTtZ0EÑiº9¹—¾xy^úb˜¦ŸRvjEÏï_š¢­ÈžŠ^c¹¦äÔZ¾Ï_ZÐaEöÔòª§wó—ÚÍýµ¼,(‹‰OÀç;M&6…a©ÚžÞ5_…W{MÇä0ž—ƒ}ÉîY‹íAoÈ©³”³óºAÿéjþ©}£ ,ŠMñEù—bÍ|Ç‹xÔñóêØdÜŠH5*ú™-sÜ3_†/Ò5±½ƒº,f_XP÷´çˆó %ð¨è?ÃCGÏ‘~WÝuø€ÎÝ¿V*oóôpb¦½\¸MÙeïªgú.¡ÓqcÀ—öA$D%Š$ŽÃ¯¹E4[ñp`f½:èpè;–­h[Ú&a| ±T¢ò/>˜YéI»½˜“sÔl=_¤$à‚cŠÍv‚]«¢µ'«juÆ!s5–ÍŒ#Ü­ÎýS’Fï·tÏ Ûþã1¦Œ2Í:ÖîÖX‡ KøˆÀd3É\.ª„æÆ’²ª3¢‚ >Ãk[uŸ€Ç˜¶©†ƒéÇXˆ¤Ld Y…2«.’=8Ûi¶—fòTÆ^½8w¤a`|†öKæT*Žû:h¤Œ{E1sG@X#í^" ëçZ÷:Ül8‰$äÙ¤ çTv03·@`DDDôãB*žÚýëÍdR¦^”kk6QæªdvExÀp2‚ Fœ1Hŵ?ôç5בê¬NÏUg¬‚ X^ÆD=82þˆ– g_…tEC!ñ•'—ëÌkZ]y‚c²Â°Jžhò„#ŶÃD¯¬ Ü ¦’ªÀ A\Æ Ù½këlÖ×{ë< yÊ=ÁngS¶YWjrÖúCáÄÆ„äL@0áÚ2¬ng8̬ÚqÕ ¼¿Á…e6¥ï`ƒ“Ä(Kí8+',Õ Þ‰x’Ñ&¼XwáLé.Ú{“Ëdpû Ó¤f­È5“wJ8ú¡ÔÓåœvjêw:¦p\àiGÙ2O;}¶cj‹ÑŠ9.üt mù§°+µ#z÷å® ÔFÕ[hµ* ÄpÈFÕ6ŸìåpÖX¼¹ªÆ›ã¸ÒËب?xsxpT[ðÆWÞº—£‘åápBÁNHbw³­`WQ·'Ü…bÇ­VîJÛý`ý~À} ß‹÷Ý0{Q;­÷"{Œ½™¶÷âzóüƒŒƒ„o;:]p7ÒfÕm´¶þ]Ùµ¹sèNb[ò艶Yø8Q섶¤‹nžžÌ°Ÿ©žö£M†Ósç3CùvYÍ0¾ÃÜf¯M[±”ÉË žÃfëq62ˆy—“ b²™É –.oaù¸ž¾º+ËÁnôqw62Þy½WA­ú®¬ƒàŸ2x®·Úb½>(h„ôñ‚@-‚σ÷ØzMªVj+¼qŽiÏa%D .úÎKƇƒ¨4Ÿ¼_ó”ä8Ñß1S*—‹Ù,¼¢Xê·ô3}‰`j5h¿ÜÏhD ˆµßÌ¿}?èƒ^ñ"øßo“œÃnè[é­Z¾òZó¿Œ{Ì{ü2™1‰’é rÏI•áè1QÇ/8¼ q|âàÂIÿ5ˆƒË&"è7è'£¼ ¢õÌ$ 1ÁMÁ¤)âExê{’&ÆŠ7d 8Yÿ= {ðÕDiŠÅV_õ°W\7>L‘: îoÞ½Ÿ2º!úú‡ 'úî:ªîcŒE‚±H0 Æ"ÁX$‹c‘`,ŒE‚±H0 Æ"ÁX$x‰Epææ=dÿà›ÂÕüOdata.tar.gz0000444000000000000000000051737212700012423013362 0ustar00wheelwheel00000000000000‹Wì½i{ÛF¶ ÜŸù+yîPrHŠ›6ÎM§e[qÔ×Û#ÉI÷ë«A"/J–Óžß>g«$ ±œ¥ûÎ?Ý‘„*NU:uös¼X¤~˜ùQö§ßì_»Ónï÷ûjó¿ÕŸíÞþÞŸ:Ýø­Óíw»Ð¿ÿþäµÿô;ü[f¹Ÿ(w³ ˆè÷Xûêäþ›üóyÿ¯?¢¬Ù«{“¤æyÓ`.ê ¯Þku[£ºy>¾iŽýñ,ÀÆÿÆë´ºuÏ{â½ cÏϼ8ø˜{¦“w¤Y˜ÄÞv§ÕÛñÒ`žÜ™w¶ÝwZG^¶\,’4¯ñ¤V[…§_ O¿Õií××߀/vZ{ŒýÒøßázçOüSÿžüæåÉ«·/[óÉ?åüwú{½^{õüÃ/œÿßã_»ÕÙou¼íþno·ÛîìïÔ¾YýW«=ÞwŸ/Ó «ÕžzžÀ~í_nÏò|‘ vw§a>[ŽZãd¾›Â©nNSìòË(ÚÅî;ï,XDþ8`Ú0O–qîÝÁ«@0î¼4YæAê5½‰ýù2»÷oüÒ/èÖƒÒëv\@îÊyÞÞu%BàëÞ2 ã©÷<;ÏÓÀŸi3 o/ýŒs-º'qTú9nÒ@õŽœ€êP§óEÌX–—Ø6¿;m¥Á8™Æá§àjáÃZ¹-ì]øQo\¯»ç¶Z{Ø;?õçÙòÆIŽƒ+Ú¸Y-`Óè÷ã4õï½ü~+J@N“ø“ŸÊT­f÷ÝàB„BxîÒvmÌüÛ0I½køÿÛw§oßœ{~<ñ¾?9~wÎ-ƒ,ç­öÆ~>ž5ý("8ƒ¾X”~››v_€“½¶Ûö·a6Ç“‰7Lƒi˜ÁIz7Áý]’NhFþd‚¸9r•Ì&ÞÂO3¸WiŽÐcîç9þù%ç§ç¶ò=\ù‰'¹7O&áõ½÷½ŸÍþÁ3ÉòŸfáü¾ô›YŽMjQ»½®d½.@ö='ØS€/Nî<ÿ8^gá$@ìÈÆËàê:MæÃ/ÙënÏmÁz¸`ÇQÀÌ—Q}BÌÚHØüÞpÞñ°áÝÍÂñŒÏ!P`Ãk/î/'HîœBÀ]x [Âx±ÌñoÀr!ýÉxæOý¼|6ªÑLæÐm2‡0™çxî‡þ5±äÚ›‡“IÜá’Ú~ÑÂö{N°ô{êÀÏ‚°LÇÝêK`Ùsý½®ÞäIpíÃ>ãž@² ‡ ò€‚ú>÷±#lÚ­-­Ë™p$Q§1| nªÐö-£¸#Nä§ õ' ¼5²R­v3™=·ÉìéÉ¢Ò„ó ã¡!œ%fãŠÚ¿ìí¹£=sŒÞ¥É¸áßÏGI„ë ¬.Ae7-ëÀkµZ_ß¡ÓõÝ‘. Ï€= ÎATBþh¸Šó@ÝC·­;Ü“3á{ð±—I (‹Eàëµ’<l¸Œ^S¸<á* ¢Y’Æ¥Ÿ.ôÐp¹Áy¤àäëO‚Üž\*® ¥è;…à$Av*ÿ¬j-åߺ§ÛºÓï Ÿô×ó·o„¾¢-–hvÓâ²ê;›yò$n2nÊÑMaJðb^~pU«^S76³Kl&‚)÷‰ è¾ …̈áH¸ÿ 5ÆøA`Ë'Á8ÔԽؿúñyÀ8ådÆ4ò}äF¾ˆŠë@¯a»< /¼0&d`¢CÒ 3€,Ë@ žŠ¾ Ê|á]³ï&{í+VyH$hèñ•ÀŽ£%ñ•CᘇŒÃIr‹}Åd2aÌÄ€©øãö‡ †EŸ/‚£ò{O5j˜Ü(ÒA[Á,TZ”H-¡†¯NŸ9eÔ]6Cî¾ô[ÒfÈ“Û5y¨NR¶Æ™7Óñ0öt¤2ˆÇ÷A¯Ý/ž›/»1 ‡=ùò^»-GéËÇy$¬?o¬Â,™à.áIQ÷ô†0uŽÜ®´#µA,5uAY„ÄÀøç%2SÀ¡EÆð™«|–Á¢åMâ—ß*ªUd…>Ê înû¥…½ Ù ãÆv;„ÛùmŸ„Ù¶Þ8Gf««ˆ„šä¦[~b¥Í,­É>Ú_gº‡£¶:¸ üñlè¢DÝy³å}<Þ,ûóÒ¯Ø Dm7ˆp³ŸÝ#S¦º³V=FÏ 0ÌdÂç!¿‚t’$xÇ”¯–ÕAxè´yнÈõ±xB ÍQÚËg~ ü}À„ÁšdQ9•À ÆÓµÝ5(fœ}÷|ÿ°wÈÔÞé%ò)r“Ð`¸7&r d°Gå’%4ˆÜvŽè¨ðö ¤¬0)3L&¿Ž}'rÝQöJbøN¤XºÔ⎠Hë6$„RÜàc¿BQX<7ßÁ/ó né1^θVpôamXí…,>S×»bû²{àSæ.PõÜ â Íò&0;p‡H`‡EuÄëýŽÛ÷Qeú|õ¾ÕKÂWÀÐÒ 7‚e»íõÝSŸ¶k+÷Í"òQ»€ôšO?3ä¿„í¹Q"ddßom)å­•¬@ç,˜ð­‚Ê2­0ý2ðöÜî–=á‚!ëp¾ˆÂq˜#8ÊL—\+ñ4Œe=8§(kÙù¥ÿ¡}pÿµ Ç7 ¿\C¦ ìn§`OØ X¯¬B$™_ öðkŠ|‘ ×›ºßu®^û7Ñ-‡,c£·#= ^ÜŽ¦\Ž²|Ç ªN_X3vaÚTÑ봃 H$¼£A샻z²H`—媜„××AŠX)¸9\m·«²Wåë`ž„Ÿï‡0&ƒ㒆#9X« 3˜C‡ôÞƒ½¾!Pæ~ L|5£ (ýœÝÁ€æFíÚ^¿)³XÊœñ›De‡Çc”æµ…šZéÝ‹€šyýö>/ê0ƒIó—§Ë€ébw’¶dIùÂÚÌ,œX¢6Y”ÎÈ4nô)"ÞÙ˜¤9ýc Nó¼éòaý‰Éd}E<Í+h7 cÞCÆü¾-|ù7ªñÛnÆ2žÚñd ÛZÓ5ÐÐÖ4^Ž‚¨bؤV¹Ýwâ ;ƒ’iÅù篃wš[i°,¦8f%/æ¶Æbs÷ˆteÕb9R¿næ°­'$ß<¹†W¯”*‹Q6Mæ~³8HË©–ÝAÃêÆ>·̾⩠Pî¡V5:ëù“[?ÎñF‡kJ4•ÏgËø&˜ ÌO°RŸ‚´ô«Ò¦;tº9¡» ¢0 Þ$yx •Ð5pÖÑf.Æ;9Ê—NÚJ¢öþ†7R˜ep!ã†wõzØ¢Å{×z‰*(’–y¨ôÝãNáÞÓiR 7é•í9R*Þn‘&ËEÏ š‡†¬~zÌòéZfl> ãˆ0yQëçpÈ]UkQ5Ï è‡†Ž(øÈÊ‘IÂr!ž›ï¹Q˜=cne.M«èÏDKDgí,ÓŠæ~2ó´œ7ã&£ÛöqßÆpýÁzÃSÞä€Øø3lˆÛW^Ã=,®à 1'“ÉÜÿþÝ„ÜšÕcWëfîj“¹ – PœnÂ4¤ÃñaÀ¨t)JÐ{jxÜìË™¶›F£M e’)Я×úˆ‡3øȼ;1À[“mdˆ¦ø'lo:P†ÑMQÕ>Ú_;±bÍ]´dÈ;t‘wØßíºñG›Únä()ãÍ*ï f'éœ-žðãÃ[ Dé%3íI:i|QÁ´Ùvà…e9Z.»²ÜG›éèd¥#šÎ:Þ;/€ýK›QâODÑûè77Õ7I^Ô–ÁŠ8YPÝ/ïø)œJë÷¡·@.ì ô6—°2W!í+øEXÚÑ»™ŸûÙ2Žï'Bi¡‡^%%ô&¯Ôƒ*ve ’(yp¨@šG¸0˜B¿ÏÃ(½)àܺ‰Û™·=HnÞà:YÆø9ò'Wâ¹Ôð‚|ÜÚa*†Ëre¹nÕsé:Í¥»6œ¹Øfb{ÐVC%:(«—=§/ôÀ RÖÔM Zæ4VÎ5°äÄw_"?¾+h‡ÑP¬rÚ_l<óã©œ˜Óõ§Y²´ÁªQA»ï´®Ä•] W#&À¡%íòiºö#¼¶µÕp’Œ‰‰ x ÈäöÓmORÿ¦Üæ¦Z5=wó©kw-WLÿ„ û®Q·¢OöÔeËUrBÇ°|ç©©Œß=rÒÿõµ6KÛ“ØQØBËŸ…|Ô6"IN7õ]Ô °2Šå*–¾íä‹wÔ3Ú<5S™ø"Mƨú™S¯ŽØã˜ìTsƒà 9)ÅŽ«_âYtºÆA”ˆÉÈG¾•ë€JÄã³ í6¹wçg Ag‰°9,øÀÏH ÍÖ9:¿iT 7éƒá¦j+êmÅ[Bí+^4 ƒL´AŸÊï(¯äè î»p¢*N0µ Ý…öžÅ'¹œ_k`0x%#XHÆÄô&*ç^©EÑqc®;f÷mê;ð„º‰íþ™èo™Ø¡(/íÄ__/c?-—4¥ÍP¸ž£$×5Jäe d ÈÀª¯&ÅšÏA=Z™¬62­›dÄw̃t PŠÞ ¾¡3›@Yc7SçÀ¬1p èÚ¿Êm‘Ð^ߣckVÔÚÏ—9:ñt-3tã°„çM5÷È«wWïîv{ðêD9œœ€Žº‡y¢õmáù¶ÎÙ  «á/RR#e)ˆUǃÁ±ºMÕs¸Éur¨‚ÞæŽTÚÅ_vßÀm†ã]Áí!Ûä”QàE6ìðÀ…HAo³z%gÿØ'©V»œIªbÏt«€³·wätÔ ©¤…L°×ií·ÚÊg˜\Ù3ã¤ùp¨R¶Ùwº‡ÿñŒ©Â}˜oˉ5éeÛwZ¶}åŒçYq¶ùdì ™û¾ÏâuˆK ?•ftòé>®Ð‰b“†ëÈ ®#Å0²V_'s'^”ÄSíÅÅ—";KÁ©×Dhcè;N» ý×ÐÍèYÑý~PŒyÑ¿yx†L÷ÐX­ÝÛ#§ëûÈØsŒ»¨¢šÈIèE¶x°+8pº"â Àx¡Ò>Þ¤ûÀ˜In–Ùì&ˆ¢ru‡nÕ+¤~~‰Ü^—–+Ä„Ä]aŽØ*V]Z_èNèÓ`Þ˜MpòàýN… RZ5tb‰ 8!¿ aF†òz׬½1þ±ZÌa]9BÅ"Bï0ˆ&™owÔv"çí}…Jˆ%Ç%"IÚó˜Â1èæ/ùÖÒ”5u­ÓsZÅž1C2h¢MPJz—ðú ù¯àØ^½Ø"oÉ$²²Û{íö‹øÙ+Ôð¼Ô)sßI@lzj|qñîœ0{NƒyÖJÒ)}úmó´tHx.¼PÃ';À ‘â²_Æ 7t¸ï"WBo <ƒ·ºNouå-'Þaß"æB Q_lðuø~C6˜Å-‘þ3à˜qè—¨t)ø˜b~Ä)Ã<ñÙñ»S6#Ù¼j;¥MQH'Sçá¾Q¬Þã uK^ÍCB@‘G ÷;)5)¬2ÂéÔ3|¬ ’V(ƒ¥M# {¬vŽE’¶Ë„Þ¼Ý]…%ô6<,ÜqWIz'qp•\Û.eEõ¶:Êï“p\›%\2Æ?U¸³c“lñ“ú÷€Ô¿úb²<Ý_i‰±6øè£'Æ•ÌžøùpäY®á-s—¤7*¬Îï½›qüš$Ô(Óu ¼ò+úJj0 ÈOé:e.ð|öο¹­°>ªF5i§X±*¶"R—oÌLþ(„#˜/ò{ 3q>ñ'I…× ´h÷œ`Ü#e,šøÊ<™ýqN«•f™üJ§è§ –q•ÿ[Óøhø7þ(õgn̺õ(‹8…±ŸÞ70¤(³ýn2΃¼©¼lè¾8'Uö©²Ÿ‹"Z¼s”a°Ñ['Ìmf÷À/}Ë…’óÚUø=zèswätîŽ4i_Oåÿ'`­6^òî'âÈ œ#N1+QNßZSȧµ¡ÏªA·ÑK?ËM ¶C'uhÝBZ”³ùoË;t[ žZoÃd™¤áb ÒeH†HàPZubIá6i³‹íÔ>µf‡N®z‡ä©§Î¶¿„å†3ö†Û­+8wP¸»Fw½$&-'ÅþÞ'Ëz¾<…V0Q‰n­i«¡ ül€´·jÇÇѶqO 2A]wi!]án¬Úo÷w¾@š§ü‡]ëb< ±›CËÊ–&pya½µ‚7Œ žBÁ.»q…'›4jðœ¸Ð.žÿÔìÛÆ(ê£k˜…ð8ã,-‘Ÿ°ÅUNâI9'zCxDÓÎ3)¤‚´Ä™7Éðlq˜‡&NpCâ´þ`H§y¸cw ÄñïÀTx¿˜f½‚NL2{ ¶IDmQdœ6Iª1¼°gNœÜ&yâI£@µßwóÙ'$Ýä†n@"ÊÚªA¤ ¥oØm÷½7 »äDü]l‡mG5é¶Èó*@Bœ[Àá síGÛ¦ïk9ÄrYGþ§³‡qeJË««ýÙÑúf®õMg²à¦.Þ·x Ž*F # ÿƒd>" ¶Ø ¨ú{A¸ŒE© /Ù xÒŸŽS¿½÷kÀ ‚ä;XwªÄÈR©ý#7¤‚þ–ı*;U ˆ/û‘‹z,Ú×' ЭƒýL„"œˆ!¹¬ä—°ÄN’7ô.µn/aXcwáè±Lyÿ~iY¬Ä„0’A(ÿåÀzNýëÁõt\N|ØáÃ4ŸSÑÀT,kâ‹„ïÄöt”LBýŒ|,ןQ¤S8^¦I´&IoJ'œÜÈû}ÚmÙYD0#@k§xr0QÎå_¶«kîKû‡.r?ôÖ®ú%ª,¾«W´YvÀ{ãé”#8ã ‹lëŸ)åOƒLé˜[,F7.¾‚Œ–‹>f,/—Ò!^Jõ³ù¥äó³_ò#®ž"ó/3b¦-FŽ*´Ô¢®$§¬Xû½ƒRXÖ¶jí¦T×ÀkŒ+çò¹IÁåÄ8ï[î{¸Êpk%–:‰0ÁÂÈOA<-ϽeuPÐ9™[öÉÜr¶Œ‰CÊÉÐËY`½n«Óê4ð÷0—þMøØmuÜÿú+ýFùü\èHÏ)±ôÖ]šR0ƒÑ*¤`P™°€sÎîU"Ä,_ŽF8?Â=ÀÅpZ-mšu¹± ·Ž—1Žÿ¤ìýÈÇ[ÙM%d› ToÅæJî?ÿ•Í®“ru˜´•<'•}òQá;MkèØ L'ˆµ²ûQÖ±k%s:²8Œ”ƾèÏèäθ¿çò^GûaØ>æ*9#]`ó1ø…媌ÍñЛ”ËÝ1AÆ¢u!ÔÇà6,_tjÑ'­ïtÒú:e§mÅbõˆÊ-²ÇRLÆCö¢¶|5\Ö³¿©Ë®H}Ëi–”¨Ã¤f£½%1öÓôžÉ)å£Ü'¾kŸø®çhÅ©~`;ÏÎá7¯§4ïæEêÇØA|Ýc8tø'¬`…¿»ÕCß<]§›+VéÒ­f&{{&ÑBgÁ`ŸSà$…Ƨ¾K›bœVÊ^¬HêèÕ’\Š€X:/WîP ßûxï÷w»N×þÞž‹ô½­ð“ÈŸ&~“……2h?‰÷XdcŒ¼ Ð5ª<ÞÃî¡\Û:.æSè]”•Þ«¸M=Øö:'p,i]QÕ¡PHN‡K¢Ëj0àh\nË‚ç '«òY•ÑŸBé—®ˆA½RÒ:`"këîI@Pke°ü€>W˜±D6ê„¢+U£|Ï ð=!ñ WêtÄlGÍýv§‰iº\(ÔžŸ·×Ý·4ô²¤x˜•Û :ÚK·9N`¨›Q£[+[®ò´S‘j¾7Þ$ŒÇ åtœr)ïõÚeö̧iÊ\<1¶¦+aÅkÈÍ©l1ÐhåU L3ã ÓínSq:ٽ΃I‘]bŽ}°1P'³¦_Œ3*>BlŠzzÒD·³Š`FlR`÷v ß&N_û¶B£1u>Ïý¾Ó÷û²lì—U3g#ÍÍ9ði{N> {¶O+R¶•}Å6²\ïhQŽÃE\oز:‰îÄ,Û{NaŽ{{æ`-’, Íáb¦½Tß”‹ÜÛw‚e_ß5+êœ5oR ›ˆäÊVˆA²rÅéf©i ÞÁ}짓yEºVÕªfràÂÒAoƒà‡Ž;¿"Ñÿ”Ìbbsz“Š®ÛK»¶Ë~@o]>Ùj› à oi´[Y͉&i¢J ¼T13¢Ë›,ÌË•™Ò¦–Ý)¥ážN_)bÇ Ó“kâÈ2)’LJø£S`ý˜ŒŽfñ|íQ½!‰pòúÞ;´rí§ÁXiΩ+ö€&œÑAÖ¨pDÇŽSR!è]’f±ˆ:žáÞ©œfA ¬œŸ±"òT¬¸n¢¥ËQ‚Þ Y5³Ñ“âÀrðeìHfdéÔÖùbžs2|Çy^ž™‚Z4Ô{NP[QO,´Ÿ£÷ìÊQÈ$™ú™ÎS*îsY T¹Üã…š4x‡Nàá–¿Hïëhõ\h­—ð›Q2 Ç’äH?d•É|¬jrhÙžÔO£ë4ª|E¬v°NÇœèÒùM¸P¥è¿Ô4Â.áƒrw¢{0绉ƒÿªHw- ž@=ËŒ²ÊŠ²1ž…ÑÄ"Š˜`šÖS%éa^Ôê¡”f_$k:ÝVsÄÆi€Þê>ã}š”µy8W.-› N‰ƒöz‡kÑÏ–àM×bqQ6fFœ²ïõ_ñ•dª3¹ÀUt‘u2ÄN†9âB 4*“œ\/tnR…†›ssNÒùœ¾£\¢6δ湎k(™Ø†ìòöÑHÊÂ'3±Ò±±w_ÖâÉi…{µèKÒ‰>T¹ã©(& Á[ÐsÒÌüëN=_òd̓Yžå7£jÔ`8­¨²æy‰¿ªoQ%1˜c&VóÃ$p›a_7é…æm·©ÄCø^ž$QÖÂf FÙåóh·ü•O+!]f·ï¤ôÚï´5’³Î]‰SX‹õ:;;áBÑkì&ò—Ù<¸¯ÐË™æ]V/R]²N[b&zgê8]¿åù€8hMy«c å+~OZðøkrXåÔ¨Ó5ZÇÃnâ€àêk÷x Sw¨ 7ñeâ×t œö$ÉÅ„Ââ–R\N!Sîæ 9ÚÌúVÞ«f¢{­T¬¤¸äÚÓÎ!/’Ü•‹Á†ÁI Ç\†îÝÛó ÀÒûbNvüþ‹“W''E&"Ö|QåR# ('•TßRI®…ª¹K´y*Vl5äÐËÕ­ÕUK`Hƒ ˆNIEü¼ÝE¯jÏiUQx…™+=qõÄÏ…U(XÈ hû§€ gJ}5'Ð)'XÏRQqrw”É Í,»²íèÈcò=),,;4­Û_°Ø=·ì/ПÂ%ûŽIUû”½ë‡}‹QÉ“(â0šáFiWQù€IÕDž·Ùx,cEmAÕ\zvïáî¡vyÌ(Åvø‰çÅ6®U‰N$(<é9Yz6©å"›Þ™»†G^ÌLBÒtg\ÃÄ5•jË÷(ô—;>öSqô-ðØÏƘBŒSrTBœ1u@4åÖÒRW‘åóê*R‚K£:æGή£³å[Ž4+&+sÒ%Ý ßœY‰A|+è¸kÆÖñÎï9Þù:÷ÎkL°h×4q¤¨›—ôøä~ª¶l[å™+†\J©JŽ Î?ž'˜¡5iu$ÛúÀ¿"x±` }(TÓRø‚$G&ë•ÇbAùÊR‹FGºßÑgèŒì.}o’ªöèF¥ÒÁo(gK$öxÁâ޳͋Sn8©ºNwh··VáA¹‚*‹Òp¥*òw)T݃–‰ódö&`,ø‰hŒgåÖj×3q\î® Yw̵½7vÚÏ&j¤,Ó{Îg’3÷ýré×î°ƒ’D•ËýÝN… ¡n²=§›lOM%Ÿ¥\AÀe±µ…'D-<¯È^s‚Ñ@¥Cš“ë ú£Ò˜½ÝÎAµ„D3sªÖÛÓIÒÄ;ƒëïFBÿ2É Eù(”Óv0m©B)슌LzÄ®-Œ^ŸÂùÈÏË•áҦȣ“¢·§‰ºd+áÄë˜>âÝJîz奢Yí`|3žùa…ÎJµþ¢{š5®|·pÚ4LCÄ&C®¦ ĘHàŽ‘Æ4¬r½:¢KÑFJSk\6 æh¸ÜN_4Aš„pº|9Ew¡?ÍL⊢í&@Aoa†[ܺÅW–a †™ÔˆÙœÜžùwÌ ±èN2%)4qd\p­¼Üñí‡:È£7-ê\¿l!ÿ諼ZmW¦!yäå–p‡›ƒõŽ-¾›Aöèçq7çßž“â²××wJ{ ùšTÏ}Nw©£8vQÂPxÊb²Ìrÿ6ÉüeEœÝpõîùþ,œ—K¥¦Y“ §°¯=s$c”©lµXÙ « wÂØý4"PU¨Q5*Pºn…>zœŸ ÚÇc¸RÙ@Dvæ¬ôØsd6÷8Dš"bPÓ›cÝ–tÂ&¡(™NÙâÏ|oC'ůê]醒È»CÀ$²2o“Ö}†¼l9Õ•6ÂÅlÅZ†ì:ú¦×Ií‡ÑàM=Gà¡R‹à«RÚÊTÇDdÌð#i¸ÅäÀ±g'[s¹µ{­.åÓ>|ìÖÞsÜ7ÎÊùí"åä™úèçsâ„ÆâçšU)q2®O†°vÖ½Ç`uTbRœÝóu? ñ#o»iŠ©aÀì<à<@jÇèµîQ¿ ¥\å#¨dªï} —šìtVn™†˜%<œûÑ®ÝyÇ›ŠZÜêñØš†;)8zGd é9Õwèõ-kÐ@Ôͧ!-ÆëYÖ–‹[^§»”ÔSÊê ˜„Á¨¢†Z0Rí9]V½ ¥£1è Å™ù';‹6y G÷A:ûTÎ¥ªFVÛ­ºR¯môÉd¹µ¡C_H+1£„Þ)Ñ[¯mbìÿöú•í~Α#ä@YôÏF/òøxØ ¢mµ¯î‡J"ôܨG§gL \}Q\H^D¶b`ð¨Ç°xO“P ÒW`¿]`î9jz“F@ê,b—˜PùæÙÆz­ü1SñŠžd]<|F§pÓ^1Ü´Ôœ© "“cåЂ’´xÄÅ0M‹’Ûª´|Ô¤Y¦CG–éPX&¥d´r€˜a´‡í¸²$ñÕ–Â{Sä6^NúêóNšZ³Ý9Øk°™óêã<’*·Ë(R‰nè:¦:–t7ý&­È¯HûÁy¨@y†wúÊÅdH¡R@ÍCÅF£OdÞľdµõÓ¼!jÁ˜Ù35ÊÆk¥sœ‘ùR¡Á– 2#<>o*a7$g–‰Ü-žHtJ§Äs!ãoã×FK)ÁaѦnßfÊUÅ*ö¦“†îu5¶² 3'J,~ÊÙ Õ²Œ–´T–®é@:ž±>ÜZÒ$Ü“ö¨iV§©üY²€Î¥qG}£ídþ±yww×ÄWšË4"Ãr0AOt»Ôˆ@§¨fG™÷Ìó9z=%ʈë7Xq&_ºŽJˆö^‰ñ@„- ¨\ZMƒ¾X)šƒõ¬€-±¨¬E–ÊÕ †’©éÌod-La1’ø.+$í¿‚8®ŠsGknèk´§O´§½ÿ¨bãÀQ±a‰#•ŽñN+_Á&4AJwÿ*0î9¸Gõqâá¿ÓjŽ;ÀÜ»$èŒTÁÄuLXJmvÉW7 ]´Ð{Å)šKŽ“ä& ²Ö$ˆà4ÅbæÏUvI‹•Aö·ô“Ø Ä 7ÍYç@¥e0Eɾ|Ë÷W§o¾{[¿#üˆci$].e…·<ÅÜÖpßq£µÍóXÅO¸ø1¢<½ø$™ËG×)·{dü¤–£ yV%È S.4DˆÖ| ÑÌ1VuKƒ8MKFѲ"ÕA¯·ËoéúÞ™é¾exž”0ðä“4é${%°³¤ :cJæ™_€3NdÂÌy—Ýhx‚˜‡Mkçá8N4ç\!ÁG¥RJÌG„7+ù7¯Nð;Å°t)†åL|‚$ó+.TITò>0näV¨—GÞöÛ¯ùÑ /’3|§Xœ®ïmcãw œò'!—¹ÍUÿéTéAD â( w÷²O`“/©bfÝ76'“epŒdJqÛ›Îá¡Ó×W&AÓT«ÎŠb®Ö^ÝÔÇ­«ú·Rª÷z’ÅI0¯ÈÐjÚu±JÇZ•Äwœž;‡í57YÒ姚q>¡#ž­f1%£Ñ=3ͪ‚2U»VF»\ŠDm–ÏÒNÖ™ ÁÑ £‰òÇ7@áƒr)A·*÷c_#†Ž'OtÏIªâíÐ:G+…s`QÕ弎0VúK“ µG,2ÿ"¬9ÁZ¨“¢Y•@/æVÙ\SXâdÇ~4F´¼ñ³OYÞ•_´V{Åh,·“{„8çì¶npù) °‚Û0ÍŸ!æ8i¸Wå¬<¯„ë²(éº:NÊÅ= ®#qŸ¢8Ü_²º ‡Ìí< û™èh·Ÿîn¸îŸ*VÁ´?´ *S8‘Ë4„™”ÓJjª(£‹“ðDÊŽ â]V®¹á¦ŠÁ¤¸Ÿâ2‰&¥ !úô…æ4)OÚ¶Ò§bpÎqTiѦuWÔhÏH#™&“O÷qEÚ¹ÜæŸÀ–h"ø~AGû9Õ\Ñ»V;¦l úùà¶?ÿþøÍË“Wo_^në_qfž¾ÁR¸gÌN>my4O8¾Q’ÜÀ ð&¹º=Žj["hïÐÓŠ–ZÉ,NO™ìb"?Ô©(pŸ's¼µÜÌ^V¤7 g+ƒs Ú’ ÷S6°ˆé¼fs%#X34G·è­­¿ãoà×­êž<ì–E´ÿ|ôqƒ¶øÿ(*_¸Ð@‡5¦ls!Z]0ÖN˜Õ¦\qÔ õî]TIlœÐÝ̾Nð.hµZ(ŽbÑŽwËlfº.–˜ù„줨¯Y¡ñ¯$N%!…Ð×É™|‹g“?ÔòžG˜Çñ²n£'7ÏÅAñÊñ `7”ÿZ &&(©-³¥4߆Áœl ú†OÞyÿ^Ÿ³Õ€@5(UZý6àJãªÀ7yE#u7 £#Ûñ= ‚‘Kj—/)k®Gu»ÜÔôâÊ;oƒ×¼¶vBNuî¼c¼jj5yNG»ò|rÕ°Y‘ {ñr>àçòûEÈå¹sŒ%ƒóJFèë•ê¶"+S.ÝN—SÛåáxIAÓp¡á±-‡Á–r-‡iE+q]úé¤^ø«™âë«Ï˜­×Àý¡‚û§þ“óßBãÇ?éü´ö×õœÿßåæ^€Óɪš×‚ßñÄ‚èáÁ?æ·Û­Î~«³C j[çòÆÖNƒ“$‘¯ÙxU“vQæ@¥,¿žšjŽÂy(_ J¸.™Dö6Î$×`›rƒÔ³Y£6 3IÑ@gÕ(îß‚yìbHWvL‰0æâûïüíw?Ÿx§çÞ»³·?œ¾¶rëøþÞjùöý…=ÎŽß\üÝ{ûwüæïÞœ¾yѨüíÝÙÉù¹÷öÌ;}ýîÕéÉ ÀÅ7Ï_½qúæ¥÷ Þ{óöÂ{uúúô½xëáe(`Ûa°Úë“3ô;¹8~vúêôâï ï»Ó‹78&pûÞ±÷îøìâôùûWÇgÞ»÷gïÞžŸÀç_ÔÞ¼}súæ»3øÊÉë“7-ø*|Ê;ùþðο?~õŠ>uü ?#øž¿}÷÷³Ó—ß_xß¿}õâ>;©½:=~öê„?“zþêøôuÃ{qüúøå ½õF9ó°›@÷ã÷'ô¾w ÿ{Ž‘5XrÛ‡?0˳ ýê§ç' ïøìô仳·0<.'¼ñ–÷Þœð(¸Ô^aG  þýþüÄÀòâäøŒuŽ/Ûÿˆ°øãŸv±ügÝÿÝ~»ß^»ÿ÷öÿˆÿø]þ}Å…*Ñ—3¹ÜfÿûE<Ý©Õ>|õáe0÷~`ªqù“iЂKè¾&»éHœö³ÛéŽk(ﳃc>#ŸösJäfÍÙ‰l’Ñu-"ÿ–Ýݾa×ÄM_¥o¾0µOW?< 江…Ëyy(‚™ÕãéSèî.£sàZÌ‹¨>óCò ÂÇ>·á[ôÝÓ˜\ MÊô.À}=Sëòø7{>ö×D¬1z±¡›¼qD_Óp}qVð'kUw]]ôÊŽß.ó¹X¾¡Qÿ'>À‚:˹õ`ìÏ~8¿Y`x½~Ê)¸%Qô.( ØI·‘ÕjMïÃ8G`Œ(ŠçÛËí'èâÜŒ“õ€.ç”ãB¹•C—Œ4%l‘úHÔŽÉèÝ$ª£©*ÿeÔSbCˆ…N¡õ'µ?{ï1u-4ð¯æÿ¢Ö×ÓM*¼e^hÁ¨~xŠAyrLÖÚ³`œ¤Í#SôôcSnJMil¦Ø¨ÞÆD)HÞyûp ½m`Ùsþ£yÑc1ÛÁ¡TÏfÆ=›IÚ¤ŽM«£‚’?oé5'^ )Ño4Ót’h0äL K ?äÉ÷”ažqª½hyjÊ`žîÄ)mR*¼óƒ•ipøI°¼ÐÙ77Þú¡PCø §â+Àk­qrÝä¤Í’}ç;*/¾¬ÊvçëoÒ0¯’é”ßø7^–w§’¸–d6ÙIM©É;hAÚ±P ?í¥ Ås+7=7êo¼À:‚Åa?ó5ýäüâzypùÅQH”CûšåÐÞœc{s%‘ŽÀÆ‘Ç'’~^²l¡&aßߣ҇ê"98K|º%õS")<Õ‹:Šh=GQ‘PÏ%×*f#ÊÌ41ã´ ÷úÌ¿C5Ò›„Von~ãy…˜Bz}^¿BŠüBáÁêuÌšK4¨ò°Å˧ê.ðg6„÷r™¦H’‰dÐP*5jl¡ATæfÓLNŸc ®AÚL¨+ÅÛð|TB-œŠúZ¸ŒÀ×:åô£¤ÌM¡~&Ha× /ð¾¯õäãQèɧd½'ÇrŸ¾#ÌÃߛႠTQƒ‘ÿäŽÿ&£³Â°Bn´Ð›Ø̦Š–¾Çüa鋆e<Ï—#ÚC¾3yT ágº"<žK ÔDç é@S–nˆM‰ÚÂ[Ö ˆÐ+U¨1?¾ñŽ­LZ…±à}ö~²:”‚Ûôð0¸kÅqð‚ R")˜òó5pǹB´…i€£©Š§Y¸?ŠUO ·›œiañìØ4Ó®†ÅŒ“å8g^=m.䩦šky(„|ªçÙo„®W¬aG οÉ8¢Ø¦wåwœ•ÍÂ÷Ö6)ü—Êý„ã41’ ÅXbpvË£ˆ3  M²ú­Þæ¥ÔqÞ”ùš#;—š%yÙr<ÃX7Þ_*F/’Ôè¾ËsËé}/ q\UFÊêyê¢Àäl"zmšêÁÊ—3#Îaý¹ yLXbG7ëDOr ‘Ua’`|Ü.È*ØOjr³yq0MòÐg£Š•¹ç3ÇbÅïyEA¹V“Tè+Dû>[MŠPSb*~QåN›v¯áqhBK…×QÃïß½<;F›Àå¶þ•ƒL©ÒÓˆ¢r§)À3¬k;å±f¤ù1e¡Rð vwïîîZF;ú“èü&Àìî@l¾ý¥9@ [/`c¯.ñí#*O1)¥Vå aîaEGý7®&ôÔØO8˜ëNÜ¡‚Ž)`‰3V¤ ŠÝ–·é„Jä¨N#Ô9ÙÄ°˜–bÈ‹jé.Ô8÷ |n=ë Ib§ñ L쀓$¿ÙyòaÿY€éÍè<Ëy‘w F%cX–Ìe–B¤TB'„QxP“PücŽÏVµLPöÔæ­‹;ÒOá48Š—ÜÅXO¡ÑŒÄQ¤.ÿî¨Ù%NTõÛN½Á‹>ð,±4$ÃæÀ«ç°´Ô‚eƒŠMüø}Õ /N^\œ”4 wÃ%°ÊL±‚½5eÌ@O̲Ê{M9]à5“}ƒˆ[meC ¯gÇðªí9Š­ÓÙ²°VÁZw„­¦®”A#`Ag^Le¿Z§ÚEq@bÕ$ª¡?%cÆåódzä^ÙΕ/` |ùÄk?öe„¡€Ç„5+%¯²Îs-³ ZÓ–…ž«k1˜OüêÜíg€ZjÓflf3;bN˜„6TÎ ¬ÔÜF4U¤|¢¡SÇ‘_˜’iEkC|æágc`-íóùÄ;NY¯ÌŒ‰Vú¢±ëæ‰âó+™Zæƒ8ÆŠîýìÑŸ@1îhR'ï^E®d ª` ™Ê`ð ED«¾« hý{–F!š«Ámä)žäÀ†{† vÚ¤Âä[qpGšØ~ôÒlš–wšIpbìiÈ52â9¶D`ç(’7@P&=<Ö¹'TVP)ÕŒoÄJò&Ò¹8Ҹ˃/Òx{x1‹dÓ`z©Gˆ’±1눨¶Š¥C»„žLkW ü½•ŽP`{M¾ŽÔC] ØbaŽà •7i¡€H.Ó?%a¼]‡·€á‡a}§áa6²Ýüô)¶>%Wn5Ž*qÅõR¾þÆ{¦¬¥la ïõ‘qˆúŽì ‚—GÛeÚhƒËgË^ ,\Ø%7’®ðÝSéG\]%ž%ל‡÷HU¿ÕþZü&ƒÂ­IRJnÕ¢%å·ù÷Xíñº@k,Rk“fÊ•ÅÑ·h™ â+]Ÿ «“•×~{í çMXæÛäv÷1vZÞÅŒ Í1 *•é`eK¼'é4…×Þ™ŽxzeÕe)ZÏ̪…CÙ“fÍD‰Ô@Ó»X1YÆb§J‘µlr$º…i˜‚ìÛy«5BñSU­.‹£ zLäüqå],]¬°¸c€(c£¶F’›W<H£Eô—1M«Ôp€PéE»·){r$V0¦$QXæmæßRNÃQPÃÀÇ€,*OgÓϱÀLT¤vL°BR1‘{Q%Á4¶€û+T{ýtÜvÊw —©&L<w¥ütx‚Uíôëy6òSÆoÒÝ°Æb¨–±i‰Îã¼ZyD׿~>ß·z/6®#Ä” ™&E¾“D,ú7 y§¥vBÒââPÏtºülà 8ëa£6õÍ°ÏØ“äJvîJZˆrà p†­Béjá×M†4C“®Y‘rÅö牲ýˆ¼º-µ¬½¡§%wæv²•…©É «¼éߟ½e‡Èí%^9Ñ déÁQ÷¨ +]ÍžÓØ&ÿØ$ªµ_43±Ë!•fF‰Ê뉪[Ï–ª•¢U“c$eFº`%š$Ù¼'-þÙçà‡R=5o;Ý^ÿkîÍß'5&'nC•jrÀyVÉñùJFª2lõ1üzÈd~„¬*LðqÝÏì[¦õ«ïÙá‡ìå4¤*3ö&6¿—ú3ëÛŵ‡ÉMyÊ·»z¯ŸÝ+|VLJšå¦‚†2Ã[BjãÆIRª‹[SE7åº2Ùb T/{Û\½o¦ãåœ"òiAÕ Sc4j˜ÝzL ©®Ýá€mC)Õ+Y¾é}~B_¸6"ÆÈÁ)÷½a¿½Ï56ix‰ YŠÒ+±æ)bQÉ|u‘QLUŒ½}ÜKº0êý0 ž ƒ06ÃÁXDÚú¼®ž@—Þê¤4|ßÓ•BËFÞ–øÌÑ’PkÂÖjAµÄéî1šPJGJgŸ¤Zó•Ó³Uì5¸ílýÎGeÀÿŸ¾&áR}üžÄN¿*ún­êh£„œ?Uߣźó&óµ]¦êñ»¶ £¾Æ@ú¸·šÍWˆ¨,ª A¡yߣÌÆJë‡^1XÔy"lo·~MïøF«Ý0߃+ýV.ó/å-MÙ¹uï[‹/¥üàìíè8HV~îI´v{̬‰Øv–L¥Ì]11±Vbä˜^»N6Eþ#CÕ„;ø9)æ lå` 6…‚¥óÌ-¯YŸb÷æ ÖÐ~ â4öáC¿Ý¹wŲV·^Á3T¿De8ÎlâÕ_ßËoD6UxöoèOuÌÀ³uïž½f°[?øÑ„ÔÄ´á„óWÔ…WDC4áØq«é³Ýïoo,v1Ýø»H$I.ê"qªŸ¤+ËþfxþjóßšáO‹O±"%nãp೩8ˆgè-3±ÁÃ~" ¯qd«+`pV›Çª9æ©ÊnËÛÈY äÝ!Q@õdùé>ü*>~xϪCMT‹ïاxmŽX£â¡ºBñ6Û©˜š_JR¤¡jÑŇޚ™8»1FáÈ„>´R À™¢›/e®|“Äèx 9½@j"Wôðø¤{_ð‘¾P¥¸ó²w†^æZíl•â²?qŒÈgâ”3n« ãŠË\5N®Iq§Ï¸â5ˆnh ÖHP{÷þbh} ÁªYž!Æ5óé² @Ï{¥š–…bªoSšGQ4IaâÚ ”s5º¿´öÝÊÔ ¶†E²Ü愈« ÊëþL«,oãÇ@>âÉ€›¢¬j¦‡YŸ¢ÇÃJ7½Vk½´=îWÅÁÿˆ-)¨dŽc,$Dž‡ñ—c-ºIxÛd^4Õ£À³ÅøÿÏ_T"iKD”'vÕƣɦ…Ó·!ˆ[ %¡•·n$om[äsøÍ7k qêbØ#0‡O ™aá a%ši8½Ä²Ñ¨hpƒU¬Xøil€µ5ˆZ¤a’Ö«ÖB°Šr“CE\J|¥­©14OA<4ücéÝ1ŒAœàÊhÇ-ºcŬ¼}Ôí@ƒ+¿VÀȧ¯R£ˆ±uKë½Vµ2Ý:GRó!IDþ«&#¿Q¾íz¾""þ –ÍÉK«¤ùý”¥„r< "”(µI‹—QT€å4gû#‡U`ê"ŽÃE‚dƒß÷’|»‹ƒI±·²/ÚÝÆa~_2Žý½4˜RÆZ§¢wàK4ÈâãûÞ.1ö9ÿÎÜ?ÿÐéëÜRë·l`kJáõ›ŸÒ_ÆŠà¹ÝlRÿß2 dz-£êÛbÜ6‡¿jÂo’\<9Pù«#: y!‡Š¾Ã)!@E8…Ô“_e+¬£POÙG….ë–"õ‚‹ÍÖE÷?B(…mgQ¾œh2r/²èЯ¸<¨œJÁ•Y€j+»B–0;]5,í8êBE¿;J>¢ö”½÷P‡¬õSï»(ñsøù,œ¾€ÝŸûFÒbÕ”p ¿½ðÉÐ…?.Â9þ*?ž%Iøh’¾÷©,ø…}¿µ0xOJñ`BÉ…¶\?ó†øÇãvÑÖÁS¯NbT«“Û¢¶¨hç½€fi¦ÍÎgTþFj™6ßÙŸ‘Íì5²o‘ûQà9ȼäÅSlè”QOS^Z|¿¦q GätGú¬Òµ̉  ¼çè¡.K¯Ú¦#Ú‹Ê .V|O²Ž!{"®)–¯±àèÊΫGß©ñfp<“&ÒRΑLùú)2†DYáT‹ oÚIQÔ·–b «AØ鉂]e¤P; ÁztëQ#¡6¾œ\…q¾&çhö¸Ó𺠯wiQ–B4¢º,ñ3—-I!V¸ÑÙs´omÃ[ *‹8@• |wkÐù\ßáÞú!ùæÏÏ[Uï|—¶:[Ÿ/õ{ô‹—[}®¯?G~^ývû±oõÍ—ô+k‘r 7˜øà2ù’ëzIþ Ec bX,++º„×%ä©Ü!¾V_Ç X|/»™ÎkË+, 7AŽÍ0B„~öþàþñÀû k(b*™(ôIþ.¡ˆ£pÌÖÇ ÎyÉ­è%»D¨‹9¶ÆŽÇ˹Âc5(þÕÞŠ’ëù#Õ§âFW¡FåÙPkµü4ôÅ÷ë!:m¹ “¤L’ÀøÓùžL±HcvÝ"/FÞ<œú¸*–©pù©Ç——Õ›e »Ùéµ^€Còö?®^¾}ûBEù{ëá×z¨y¡z%ç¯ÐD Š¸x{á}÷öý›;òâxÚð¶à9*v©iK åÇ,4I$R3Þ°y€JÞ7`#ŽeÏ”–[í^ƒI–%à…΃œQ‡ÖXX'r‹¥mDq‡gS²ë¦–ó/ ÙÁ60sÞÁŒ¸ãåw‰^X ø[ð÷–þH~߂륜¹ÓD´!,­Þ¤ ˜ôT­/«bu5S*ZcqÄãtVÌ7Éä>lÞP-©R/? †÷rÈ19ìm;ª-mê°ÁŽ­êé`afVÆ ¿Ô­{S'ñInÕ~´@o¨y7ì©ÒÍ\•°Û‘¸B%‰Tü¥×`]åæWHˆ ‡DlÈB™ˆÄ¤V“.-³*³•Ñ)p˜ oSmÕy>”Kº1ù Ÿ) f‚w;¯f½Ð(ðÈU‹VW& ë{QÀyÛ¯¥¤«»€¢¼G¥Ø©…Š§,9c¥×¡\N¯(2¬x²EãùÂäµ_Ë;¦«q¸n½WdÕUå–ÂÄ5îAšbÕÇÅM”oµ®H·êÝ}! [鯾R‹üO˜p‡æEC+Oö%©†X×$4h8X˜®ùÖf|SµYP† x"BÃ%“ ƒ&1È4{^~ôéJý‘V3w֥↷×ð-[^Ñ=sŒ)æÊPKºº¹bõÊ4*GL“T¼Cv<»ô½ÅØë ÿRå0¾î<ºˆx‰äˉ¾*ÉêdæØ<ÂÚЭ¯ñÇŠš5ž>øbçߤŸEWÇ Ï×–Z«FÕu¿ÞjÕ?ÕËÌ©O‘¸=•©ë´VždÕŸÜ„ñä*¹þv(Á æ¤dé·Cv<å#ZŠæm²{6lÉz °Iòa¨ÁQ›+zz‰Û@Ѐ±#‡N‡ÞòÎW3»…Ú¨ó¨  ý:KÞFû3ðïí–šù6õØAŽ~ÄÉhÝ•Z8þ0£´[47kœ‚]w «uÛò¡´Éïàâݬ½«(E‹tš×M.’o7Å6ã=ÌÔ% dDs*‡ {ÒÅ¢rSÞhæäŠ"úŸyðGŽ|`Õ`¡Oz|Ï}Z@W•nÙŸ®ª–Ÿà=N,Ü l[±îxs‰aìÂâú[—‰Œ«½ åÖg®y’ì` 6%£á­Kù ÔP`-ÏœHº Ð’Ÿ.9²z…ý¨­H<–¢û±eæ~Yn>­¯ÿÒúz·ˆ‚ºÔŠ2@ ûµÊàhžM%†æÂò>X#ÃÂþdŠclÐVÆÊm:‘õW˜cǺËУœpÉ+¥ 1\*HÿT<­ÌŸ²&¡±‰ä8s"‘FÁŠ¿Ö'š,sy¾ é±^ˆæÆ _Öà·úzAÖ'pŠNa@äoüb ~¡aº™Ðé§?ú³ôôéÀ{CζâO§ÆñÌ84_C«Õ b ñ.î’²·Vú1ò£>D= h ú4÷‘vú7J%©™<ÀjZZÞÛxuܲ/ ¨f™¸§ü\8 †–Bj ì~¬Ü2!t½Ø½¾ŠÌÒL8sz§¸¬83$Ÿ_Œ¾ÅOW ®«ùæßÏ7ÕJÿµiÁÿ¨ý7™—yðÓ2ä8R§0Õ†ê¶:å(ºJÒ«xÓº¯Om\©‡Íÿˆì·›s M¦,ºÏr»Š×u¤h”,Ú1Λn¬,Ð9dùØ'*çðzþ691=zã\'‰Vʘ‰ÃùÌW]‡ÙlåQÊ«S‚ø~ƒßiè~ìÛ*N·ØÏ›õËž”ìJÙ¾å0Q ¥6A )$šRDíY…^@epU®®Ã š\ÒÝ,ï~—÷DU‘ôv‹ÖE‹ÒшÊà&¸ÿVÆi‘Z€ #ã3mÊuäO­M¬®8¶}ج!ˆ‰Ã•¥¡HjSŸQñ¼T¸>gæ8…«M¨†#“àÚX.G›çk“Øç~,ÖÈœ‡n Ó*¶ê«k'©×>ÔÿÖ<¦tMÊX¿ÄÄuz¿¾z¼±x‹DŒ¨ìfZ©b¥oó³GõWB¬ê”©Iç,†ªU¾V6¸Á¡ŠO¬Û7½µ²ÕèûVDtÔ—°æsÄžU}8)†· œ‹LÍðÁmåo±û †È˜È3Ò5ØËxì/§³\ÛiTI19o_í·ÛRi ¢pøƒET­y[Í9® O¦ü‰„ÎÉ_Ð}7ô7šÖþ2…̤© 2–C/‘ïÍ–sŸ=Lü ÑëLvV•FÙbùùŽØÌ´L ¹ÕXÏ .gøWT¸l"Ö¯]‚°0ãe°ñŠpÌA äêÔ+Œé_‘ƱÙCR}L]gù‚“Ó) ô+&£ë1 p)ròvš„·ádY €U2òE°Ð‚Ú˜—1ê™åòD¯pÿ‡š€r…XLÈøáç-Jþ6t«±…+·uÙØRcbSÅ_~¾´…¯BlÉ9 -¼ ïÿÿ¨©j‡^Ð ÷hÃmrˆSÊý“)c•:—ªƒí#ÝÚìÀÉ«C+§ðÀz4âlÔåA>ÉÚ1¥ìöUèJ DÅTD_0åÖoº)Û?kHžð¾zúŸiÃvŠTÿ´s¯EPàC: ˛䇆.‚´f?¢Æp£D#Ì…«|O#¬î^×òÔ3qaÓ¹˜¤L3¥x}s’@´ìQ™“ nÝÏ£Ëí(íRÂ8ÎìrW6x<`‡TÊõ¢ÔiïázÀÈ·­×¬|ôeT¬‹¶~°Ámˆ2ØòZSÞD Ë*ü° Á”²;ÿÌ¿0æ|›R 2¹M&upS:í:¢@Á.©¥PœwÄ£®ôª2_ê·vÿ7§bø»ö«‚ØÆã^6í–šqû¨02üŽÚ[&ô£È¶­¿`1YXSØÚÈŠûkÍã#gé\J¯O6˜lèdÅ—ûfeGÖÌw¿#{`Íâg«»šS(n^å6A{‹²jÕ0æ§b]6îó*Ö®YOCÝÚ^«uYp‰pÀtÍƸº×di†û'é(¡Ÿ…hM»…ã.ð{†ly«KG³¯ÈK0ûRH8œ–c§•'W~‘Ü`IèDu>ó‘Å8Zè5ŠD]¥ºvM×îçaËÓV£;ÁÚ~Â6WT€ cƒ°¿š³¿wźR‡{§Ê§=ÊþþÄÄrÞ³‹Iã¯òö«R$íWÕTñÌN_ñíP¤÷‡Sª¼…h¾’`Ÿæ«*Ó?P•^kÃÎÑø7‘bRQ‡ÑïèP_×u»|ÿPÇ Ú«ó“çg'WïŽÏÏ|{öâï(ÌbT×Ò»ÔÁá/U^NW\)(ëkž%ÀçdÍ Š©b'ÁǺ•S õO$œót† ¡ñ&XKï\¦óÀØTI$ã’eh $³5_P¡ Ê3©S«Î´¥É¥wF•kÆë“s‡j#bb”š¬°àØÝ‹œGU`d-ˆóò¤ÔfBOÁºU•B¾,C'‚”n6&Õ™P6e S`í°«uÓd—Küž]¶–!O£òÛQǩ圮TÆ9—_‚KnîÓ Ÿ„ÙMÃ[ @ Š°“J¹-»‚+•ÎåÕQp±!…âëdc3ÊÖ“ŸñÏäK †ö‰Çµ¿ÂgiÙÎv¶Ö«—š|R\€¬µIµuø±¶*_ª»?îJ±bT£OâÅ~dÏT^ëKÅõPÛŠ‹¡ÕOtgCc×T÷\½…òf³IR¯©=*“¾>‹K*'kbgÄBíýº­l}‘WQn­ÁÂG O—µ¶Â[1•p-­ÇÝ­ô)Uõ+¬9{¼D«–Ž—®¯¹ÿ vÛP=Q~*œ¼§¯Èþj|ÆŒ Ås=z áÒè€\î´VéûåÎ&^UûÍ(D_V¸ätQ;94f$šæÕfvg0°0MoL†e~w‹t…ΕS=–¯ÞãÇwx“ý}üdëód¯@*´ªp¢aO£Hn׶]P´…,í7%ë&ô:ä‰nV«gKpG7m„B²©:S‘3!ë”ÕÚ‰÷(æu\ÕåS±d²]pò#kɼŒsâцáfÿÿeï=àÛ¬®ÿáP €Ê£”'NA–#ÉÛI2œØEì,Œ‘dI¶Ë’Ñ#Ù1h˜Êî J²ÃÞ£4l…„ÚP6”QÊ,Pøß3î}îóHò”þú¾øÇØÏsŸ;ν÷ÜsÎ=ç{¢Áp¹P،Р yˆ`»¾¡%J``#fסeNïE(l‘8ÛŽà:þ¨IÓ"äÔ;~Teò5‘¿þƒâÅbð¸Ö<ýÕÜü -ç°œ’þ×5÷\ º (xjú¬>«Á µÜzïx =ÍH?;Ãñ´jéÒȽ†íoÊ„•+´@®dKrá| BNÉ+ %¶Å’±4z;”sžåf»cbœ›U,ʃ>¦rÞ|ìéXW:Ü^š§¸¯ûØÄu¶œ€SÏd DL“¼íIÔÀ9ÎÎâÃbÿèE(ßY¿×™…€í½öAÀäK:¡ït#f[¿éaú¬¦¡SÍmK!Õ׫ þã%Ï Ä|H²±)‰Jèàk8`¯¡Ðñ•t,ˆôò“B É&3JŽâÊ4ôñ¶ÙX¶lœQÖW‘ãŒr|¿ÔÐ_ •_® "8Ìüý)PŸ>*¶ÕêQµ*ÏÃÀdX¾–0Çf¯˜%°¤€ÕÛA^œ@ƺ>¾Ù‚PæEþÜ ƒàûÄ1&ªM§zàM4Õ ·Ì8 Ûs<Â~ è ¤QÊßRÅ`qËi8uDª0“•b¢E(·çL%ÃV-‡3«DWz¸O¦}€•xµþ+= 0´HTÇ,‹¶„2t —V·eeÒ‡àj[aB5ÛM覽¢¬œ^aŠ4õί6 ^ÌRE˜N’¿Â§èýÎ`°úçé-“.7îPEY¬K¡øòƒqã ¿.·',€w}[Ÿ‚*ÂRÌ‹6VËè¬üñä-(ˆM˜c:›‰'˜ç –ÛÓÓㇾ þâ}…ypiZ¥ÿÁG¥óà£dvi¬mœ×œ<»®¾Á°Ø } :L9QEÍQ¢OÌd9nÐC‚?HÆz €ýX¿T:œ†Èßâʲ :â0è 'ÉùN<,×£×U5ZþB»Í)_ ¯U'{OY}¤Ú’ñc€-©w˜ÞÄìr”·›½I(™7"çTKÖŽú«œ¸ªÐ€Ù®3U£’sÀ’¥ú„~äÒ²‹3b™ÊŒÖ,8þ)0î"¶åƒ‹Œð*Gty5šV_[r©€-%„¨ î¾mxÉÊø›lÅŒ›.•›¹Q* ä‘&´áL£oâä~§4ýR>F5mŸqwÐ}=Ĩ{ÑA˜’döœÆé³g5ôA¶–I%"¼ü™ò‚„Ï\¬"Ãû"œ·"iηU…B©Ð´YvøZ:”ó¼”6«Œ_>ÖOÞB‘>F*o\Í|ĆAG£&! š£¨\ ýÁ\¹ýËß'!=H©—Ž<0ÆÇ9 Ý`m|Q‚³‘tCB9?9iG+ËÊÊT?]®ñª¤zˆgGi¹¿Ü5ÞuˆúC UƬ”Ìá*Þà ä÷^X’^H¤ê°"i{Çèkï°j„Ûa"åÒ²/a¸¾ékJy4e“Ö‚ÂSObE‡“.ƹ¬6Š‰}P‚zâ(kIç äu¡QW?£¾±ÈÛ7MK¨\Øz¨Õ˜ßöÏí´†.çö¸_šÃ™Àf~˱J;¤[À@Þ§±HVú±Ò­‚ôG²¼*`Rš+¾6Ès!@nÆFUñ€t+îÍ´«¨X{…Fˆo*Ô'…`f°…Ce ¶Œè8­‚¼Qh´*DÂV éýÈÎÖ9Ôá(HYH‰ G»à<ŒÐ⤯­³+ÅK©Á/²I!“Ó0>r{9‰<\±’÷‚ hTð3¼U«§5[Ç%ŒT®dEÊ0-sCNq ™SÓdé]~VtÚGWŠzY©¿: 3Ä{‰)ãÅ–U&{Ô7.Òží“+_„`nú™Äd™‡—!©R¢›XùÏCšcºÖo²…Ìì¥K&bÃ2zSSUÙhoÎÚ—pp /êô6 8>!_ÃÑž†§f’†¥¡çòÐì¾Ü_c@!6´ÑÛ‡E0¤ÌÐëAé;ÕN}‡îwy'çÞªÇM¥Ü‘U ‹YÓ˜@•çKtâ-$UIþ…²¯ÙŽ˜ðè­ «ÌÖ{Q‹;_ðß4Á/¸zÜ0I¼¢ *0½¢€i HED&+6¾5›k]h» ¦ûn0C‚- |vêŸö˜”A²] œìË¢dj·~‡MO Í_ŽÙâ$¦£7Z\"é,‚Ί.ƒ|ÿ€“dÝ-ÑA‚¥ÁX+ñ"ÅЂA/ùe¸ñL,.h„jrĶ…Å"ˆ¨N*ENéÃÊc̤QFB÷y‚S§›ŽÌ/:Ô)÷,âø9Òe#™&pÝ8‘î¢-Ðt¹+ ÀÈêÏV·VËGn6/Þ'Öä>qäs›»%ž8KÂN‘7ñd{,ÆC08 §UQNoOì‡[µ+q=;“=—myîÌ"Ñ–`€¢.vLÖ«Ã;zDç[ÂJ†¯XÖOÊ©ã€Ùà³ïERÚýªe#ØDßøbæƒ^ü¸3é0(C,r~G·Gfµãƒ|„r¡"ÚXª>\^„ùè Aä.ì6ìrîÉJ„š"û©gªå³ÿ Ø{îëW›Ò°5T$O,oN· ƸØ7© _f*‘á<çÁÞÓvý›…r=®°òR§5 èkír+Ò@yûQ™¨œüáÇùÁ ¾¼(çŠ"Ÿ/‹´ÈÉÔ{ú‰Ýg›AõÜW1 X’iC, ( ø§_ Ÿ^H«ofòÝÞR’_å}_Oæ…¹ÓN㦣Hƒ¶?¥†ñ™ºŽ™É‡ùzÓ*S™PS˜c©Éˆù¥ó]s.12ˆ^5c_éÿø©o™Ú p¡J¾¥V©£N¡QN—Ù–øÌÈWsžbêW4pkA`2¦èc ´’©Á¡@ÒR\È(ÙÞ÷¾)ƨàs‚û¤ü Ãýù É«Îpô§Tjæv\Fª6¶Ãq,[v8-Y{<•å´¯Ææ¨6ÎàC;!DmYiq`zh´PQ¥ª§€ÖÅ¢@¨ècÇmö¥ÕçÝ ­­¯¼íäc#ì}À̤HqÄåôHåxU’Z(”ÂUœZ죥i5¦”eS® ¸·rΩy©$¤5v ¶r3›A¤_òÎÍ&‰ a^hˆr¶Íô½F¡NõAC"C@¤0é¼:Õñ‹˜\¿…H*ý>(£àϺƒÞ†Ûä×9}òxÆ™xÆ6\ïü7v9ܺúâùÎÎäÂÙ¶&P(:+o—ýܱíÈK(ÓJ~ÁXK_nD–®C”£¬#Ö ~Àê¬&€.mÝPRž¥åqŽU¶Ðaà¶hPh¹?ÿ_›E¯¡~ÈLpv©ÕI&HÃD¹9§¾[ v,œQÝ>šj;/‰Åq¦t“j¾àXöwž/ˆ)c|HæKRF<"º© ]^Þ˜°- šZz˜…êaË:äuŽÔϽăZd^Kž ç]úÅ1‚'9§#ä1·%ÁL|µJt`.GÇF¸»a)­c¹Ðù)IÇ’Œìr,ê³n¢àè22”>ÐáAY4⤴eô”®È8{Ñx+&ÝP•Êøعbw™F¥ ߊu‚ Q’‘2~ xKdõ‰Wš[ææíIeŒ)`j.‚¬”âQ YæѮˣˆ(™ær"17ÊŠ$%¥oéå†è-äȳ‘¼jõº…ìÏ d€­ŠJÃ]ñÒÖTªˆV˜Ú0/2^[ <° qT‰•’èua* Ûb ÿ¤Ð1k2åªJÃ;£hžŽFY1âñÐ:Œ” oŧ5ÎœÁSÞE&Ì™ð‘`9Ü•Xrq ²6Ã"C3dª4!;K§¢­ÎviV£‰ s!@d³Få Ä‚‰ˆm¢àºáž€dm+dâi2Ñ‹q0öÑÑC¼pts²8iÔ,Et¦Xæ -ôM¦vé">$÷ª¥”*cøéF%±]÷ËÝëî.w{É”/XUêk:EN˾4n8u¸y­2±Üg¤ÚÚÐn²}HzY`BÕ„($ò’Ç×bÙoy¨…þ†fÐ÷|º°ÔÒKø…(3‹åÑ’§!SN#$7™FK3SàªrôÖ<%±H’ÏÓe²B“Rq½¶Ìá\+¸p挠×ÂÝ)ü;iú¬Ú¹‹‚Ál\Ø´w,z’ŸX0 !°À†Æ*«Xá+úFh$õ&Ü–ÅÉš†W›=):HH»Ãì1GgãB Â\eƒ}Gˆ±:] -ý)H)¦EÖŒÙlæ@M§#ê¿^¿£çÒD5Ö½o%BvcúÔVQ*ž¸sŠQL[9x”[°%ž,ÚQ4ÉÄ2>:‰s?Aû9 ð]‰0€‡iwmR•…´ ^g¼\ñپŠ«;¢)Í/‘\å|“î*-d@ìŸ×Aa˜üL .¹ (w„ § ¤Mp8З,¼Àf EêÿÝB˜Ó>ÄÔ‚Ž~àQH R%ìãD+âSWîÂÇM&=S† )/h”¥!ÅqŸàL˜»±¢·jÁ¤Á¦â,6R<Í;»â–(–;3~ ûªc¾h±0„¬àpž³Í˜Æxd†Ò 3© ’“ƒ[¼‚§’‡»K¥†çÅ6o4îc1áTeiNTO@“µzëi‰‚k~§ž3ÅZIÊà*A\a|Y›1Ť,:­êfß‚rÃB¢f?mÃH{*ÅŸk~'~­VJ3/E+žtŽƒúE¾½ÍÖ´ÞE"¬¦–^{*÷ãÓÚ ¸®"ûˆE„…RzŒ¬…6JfŽï¤°«·m_ôö†To‹[å+Qþ ¼ã.bØ*µjW6Êùsm>Wâ¬tt~Sû¤ cͳKÐœ"ãrÁs,e9)âŸB’ïI¥Qw® _ º±¥X.dKß6¦}À()-‘à1TÎÜJhoâJq¶¹K ¶|Ђ¢#¸H‹s§Óã·w˼”`¼•ßnTßÚ0„$á¨k51.•ƒèžº¡Ÿ²~b-…û,(³1Q$¡Þ#³6çöÅ£w†,Q}w'aö;£íkTÑN&N "ûÊgŠ5Ž|Tq‘Ål³ ÝËécg(M—;šMæ_Ôëžû*­;Ú¦C]bŽóöÚ’RÖa£D%9ï½#|¡®õAf¥Ò)Ä”8‡Ÿî&8%KãÐ`᮸Ÿªr7‡t§–x\ˆ¤GÙ®D*,ø|º%ž,§ëL<-™Ÿ‚&Ä@µN™nÊÂŒdŒ™ÓgÖƒ¾x' ÚªW)~Ð!´k[žÑð¨™þAàlÇÒØ3ô!@?<V\,Ë{šÊЭZá;h*bùŽ$ö4dººåóv$%0GÙpŽ›°QnN&¡fK(iü®‹‹eb¢AÉí%՘ǪÁ–Œ›×8Å7Úí±tòÔéþ˜¤²°\Ï ¡èG7þêÔBf<¤C–-z€SxŠubõ¤‡IéS*ŠYƆöªµ‡()\¨¤D¯úãR»Ê4RVRxK€p`ÕÄÖó Øüà,οçüˆš•~êµ=iM¥ZÂiR;Kê-a ZŒ*&pÒ`ïö*Í/¦¯s¶¯:j´:¼ÊÈó!˜¯’1²4®¨³ÂÈš?— ο–vT`Ñl˜Òf†J¶wLmã4ã'é¯sA›WÑpZ[8q¶%¯OϹÉóZÁò0ã«)+’3'JµÕn5¤T z(Wù¹Ù½ô¬ƒ4Ÿc·zûµú³T9Âín¡ Ùkõ¿á¯êPKN»Lw2êï4}àQ€ú©6,ì_,]ȉUzÑGøºnª faU½aÆЛœÇé×¥ƒ­£–CZ6žÈøâI}jÃéXN®iù P3ŽC„–y oíÕ”—8aø{ 퇊¢þh¶³+„5Âa–§B:ŒõeMÂjEð}¬l!Š Îv0n kƒIžÚáq½Õ*P¶1%„X§œêrKôQ³Ž‘ÍÔÄfØŠèG†vI/ C¥ÐBý`é#p¦[†{PO侓äùo^Ä « ¤û‚ïé-‰TKigØ+¤@ñ!¥ûÓ-#fT׌ò¸¨ë½›g³+*ü–T´W†øø 8òP¬8Ž/i‰ƲϥNûHËåã½àܘ“äOq}4‘[ >è{\ ð„YÉ°ÍÑÕ¤¿`  fÔF…z¬?GÊM>5Ö Š@Èæ6‡1¶†ëãOÜ}\4ÂúÓF—ËòéâPéîi(Ü/@Y>o~®ÙsrH uJÂßyÉéÍJ*¤ÍD,€cÿ4—zi3é¼® ì/){[… ÜMа5ÞæOgQéêƒÔrËe‘srJ^ÔRvE Å…›¦á.qsP4GÙŠ^)!8¢ˆÃµÅŸbtöžÎ&mÌÝ¥!¾Xr‘8gâ›f´V Ú Óì&ÉO&¨×ÇÓä”éjA/kÒ}Ñ,ö@ãÍÛS± Ô›ÌFœnŒv\ÙíÂ9š‘t¼‹t‹ºÃi‹¥W±EyŽ uÀ!Õå/-Z9E¡©iQnA@vjÚŒ3€‚çÌkTÀHÈ,¡G-Ö•‡•ÞÖe2˜W¸EÐ[èþvApäÀÖXb‡p”T—|–xd¿˜»Ìå¸ýÃí§oÀ4²` Êð $F2)lÆ#È[IÇÅBÒæ‡V‹¼{Î)¶UGî£Bý)äB :-“=‡8Ê»VAÈbDfßpv· E‡éßXù¦(‘¸c X.F¬¡’öð˜qÎN#!W&­v+h×;Ã0èL‘·Ä!¼§ô–ö¡6œTZá{f Òð­ÕÔdØDzÇcùeªŠ:8Å"Ípœr šZ‚Ì@v—ðµʬ¶”I6ãâ[E£ØÎMò_„Tê!Ð ¬”2øÜê-x‚×sZ k»˜/Yåä5d@ÿlƒLBí)töa|^ÜÛVqòü±,vM*³ î‰æfc¹áS ßV%y¶ÌrÜbŸD)èÒüÆw‡ux5‰®‹f|)èME^™&@p°6Jme)ìïÎûø8™ê.ÕÊPþôÙ@¹ y@òM݈Jï®éIpdg/4EñÖDØåì•Žµ&Ú׺qÖÔ?Á7…È©[IiìV$Ù†´I‡a=!H]Ñ‚‘î:»â ™üPhÊõ*G˜ fª,!i ¾5¾“¯ãßã@=P€õˆî3¬¿áHäÈIù3ÒX×ó€‡Î‹:Â÷î긡§¢â°u³Â•qÑ‚ÎyÎn›åOšý¦sN6ÙÙf·5e]Ý ½& oë¬LEÎS¶,¡žªE Í¹Õm«Ã€š²Fo<–ˆšFC;¸»+ÜF³­0WªŠEaÀüóÀòW¢Uçù"$YFà&Úä/G.]«l´Ë_…,ÐĤl¦Š–Ú(*íj³R¶„p#h6–ôRž xNµÄbÚ±WxûE~Ýeþòj™ 3_&¡¤GaŒÊM›y2Ë5D/X³R( p®”ibª_’—Óñ#zPh-ìÁÑKRNb|;z…¼ÃÖ×s(:C^„bX³sH²>'/®îÖódíÒR”G å*˜e“”Û´@5•B¾RUôÛ¯oí&-1i³µ.3¶;­Ëùµ$å0;¾£ý+e‹ˆ£a¢5$i+(ï&`«Ë_Y„Bf1Ñý¨j ¡!àÞs@ÇÈsWœüâ4AÓ­KÂù„ÈÃ)Ä:1Þ&Y Çžû©²kè•,{Ãlæ%ÇM ®K4l´˜µJ PŠp ¨a‰‡¹êKWœÀ6¬U¤ BŽ‹±}¸%&*YºÖ8#áü4jþ'ÎÐq±¯ xxÝ >,oÖ;¢±–l›QÔ$¾kg)ôcy`ÄR¨vy>o§IØgÜ«µ­ ø¹&Q~B&¡Ò~hph)…r -7¡WB]P1 †€b!¯‹­lô|œaý± ½Öj&ÂάJ+,î*÷«æ]êw½W¥ßÐþ6ƒ®*ž~¸ªE1ÝM&誑å ð>ë2*¯Qý¬¡È’vÎM‚¡Üª «"BBg4,€ØFùÓ!ŒÖŠ«ŽóúV¨¶©–$ÏòŽ~sN[‘T%³¤ a–”¸\“QU †üÛXjœÜi é#¯Ö³uèúEé”Ðj}bmNlI„ÛÕ¢d»3§_nM©@1}ÈðƒŸ‰-â†ÝêòN»çÕ.üdkPŸ½Mí+­Ý–pÚú8§6g}PÚY«u ™çJ%ÇkdÓÒ߆ÈØ9.0<Ë‚ÜÌßÍ ºé´›óŽ;ƒä¥J¡oùJa—©,v‰ÒW—[-yÔ(†ä0À˜a£Sò]bÎiŽ«ñ82Y^€ä9«±ÛÞ‡%gË l):ˆa8ùóÒꎴXLͦ³ Ö,€MÜdô VO6sÐØQn"LHÇâdwL™dÓ+½…‚œy„ÃbÇx Ðbs3ž)Z;Ù ¾è\-C.Jñ±Ïã*“‡QÈFŠo0ÞÒ‡;8úUñuúUñ ökkÖðœîrku BqýÖë íu…|ÍË©6Á6.~‚'“Ö]XœÜfÕ2CzbLœ U\6 ŠÆ[œË…øƒãSÊêd1ŒÃöÀž‡×]Ú–ŽÅ@vçÔ&ßxùNb¸{«fAVcØ~FK‹ä›¢@5P´ÜþÉèñ¸Ú„ûøx ŠÃ£"oÞ ØsÃJÌ”P†JI} †O Âü ³z˜Žõ@V 0;’ƒ§>·|„0´¯d¡øŒD1ö‘SœtqÓZLPmÐ $5éÅx™”Œö!¶ã7JJTUêáZöN!F“D¤ ôRt‚Õ 7Édò±r¥hXŽa|gb¯¬íL»©Ð<¼*œ±idóæÎpq˜Î"m0s9yÕG ”Q¼Òã¾ÄùmH…ˆZ—ʤæj ôE0„˜~&ÞÉ6¦î~¬Èó¸‚Ð 'ÀY×Õ‘,Äl—èS’¿Rª§ÛRÝè:‘ƒX VpÁ˜WÉN,Ó,‡hU§(À“¦]ƒÞ%ü.B4S‰né##&]ˆ$–ó‡ µ$!Ë¥ ˆŒëaÃ\°rÔÃ…¬jÖq·H¡JI«¥¢ÓB¾ÔNɦŬÏÈF: õkFÓü#ñt$ÛÙM.Þ6Ï+‡þ91s+ÂåfÚ]‘Ö (Ô¼†æÔ6N NŸ5evˆp–…šûï.ºÃé¸ !~@VõøÊkü FG:´–™/’‚ÝHŠ/´§S"ØfN‡âdç%•î\®?•vb½ ç¹³€* Ø7„fŽæ;G#´ò ×ƒ˜A2v±ªEÆÛFLô:è±þ°Þ“ Öj^6wûF`°]G:¼¶$*« xƒÄME[AuÕ~ðÁöMex ZÍI˜qFáZƒÑTÝÍ” ¸h.AŠ“Ð –Ý¥ÎÙÏ“¥AEµÑËX;&ŒF+ÀN…¦H·Y‰¬6sMW³eeƒ¡OSEßèñäChMnÕ@Ôùîò„}KÖ—£e–Ñ-UJ^¼$ÑÌásÂ=v‰YHç¼Ó×±:³ÜVtŸê FHEí±¿@§€-ÂVªßv©«ðuA¬dÛd»–^vzHíé§ë„NŸcKϧd!ª&- )”0ë Yç&1NˆÖ…ÌÅiµ@~ªNO*Ýaêv&YI^Ÿš–t*Õ‘èMÖźKÃ\Pùž#už(Ó6Hî•EÉZ’-û ×"›¦¼Yô×2šnÄ»-Á£oœ!+Èjù¿µOq¡È0È°‰zúœç™‚ûÎCN ¼Åñs¡–ØT-k ^ÿMPc“Ê‘<:È´ †“AäùAd"ÁT«úÄ5nbL\õ]“꘠½ ê饩ÙkôÍä2œxÔ? ¶ôRøTßëb@«ÂÖc;Ÿö¹]Χïä•Y„Üg—BÃ^ÿ/ê[sžÿÏå_ãŸÎ¬×&Iââ‹-¼m)ÒLѾ's©äØ!£-ÊvYY—Ð+_ ¸èjUàiƶ½Ê䣒€%½àV…AÔP¨  ³–G>PW óÌÒ„¾¤»WáJîï´Pœ ªUÈÎSaòö6Àƒ÷¢ :?ŒRèË‘8_ý2ã‚\—‰È÷”¸ìd2 ‚ýâüš a1-<íû᪒ 6è— Ø‹F?ûïÿ#nÈd[Э˜óp‚o™‡ÚµÄœˆ© ëIJ”=ăLûV¢,ͺ/³BB670€›Å\‰v DÁ?ˆFÆkmòƒãlÛ*(˜ªõ³—øH§L‚GCXlR¹1ùž“u]‰ü)»­ºiA  ߣ±Ù%-LyÎ ·>R¬‚.)$½`d-19Ëöûè>FD‰@ùÅ2f­8¢bù™*`þ‹Z öÐ7Úãú ùÅn´fÅ¢ArpÍ“½’,çèR2ž°¾‚Æfj¶¾œ”bNsÅÜ ¹KhÚɘK -Þu-;Õ† i”%㜱Öâ&»ãs@%Í+ü×&bK…“1|‰e=þ¼€aÔÞ ˜Ñ §tq`RÄ¢K5fæàðn•ò!b½4…q^^H¥õƒY=V ‘¸Xм´-7â‡ÆÝBSiK¤ZúëÀ¶s—€%Î#ëPqh2H=9Ψ‹§ÉPéO¦Üš¡ ·§™d BŽ3 rf)‘,ˆ9ÛHã­ÌÙcÉnÔš@à Žs£.Ö!ÅÉÄ…X¡ŠÁlêF|Nˆï†E¦qÈ!†[?Š)Z‚ýØÐ45óç4±ÔÇ9»ć05“Ûc‘ÊW¬šôÈesù™8tý9\ eN3¢r~Ü•”Åô®ùÙ]3o nNŽp„–Ó°6Ïfk³1¢²btEMuõ€ŒÑ\–â’SlRöUòÎð%â->¹N{ˆÛ[_š¡K«*kF®=‚ÿ%s+Bi¾ètß6G4OàwfJ¬(¾ðטy ~%“Ö@hò…!ÊÄXÐ`“cþf¥2êòÑ° YUPjûžíÈd PI(Ùã´‚Ò8‡+\x¨ŽC^¶¢i‰BÅ´uât‹+•W¡ÍXB“,>(N"?r.ª 3 y¦pH¯{=!¥òÅË6#±á)˜_—ÈÒ%Bàµy Ë«óœ.à÷z/lÈÈnIt[›¯¹¬ekÛÎ&ƒ<ÙU# ñg²Œ¤HKŒð´È? ‚-KIxNYº˜Ž?¯‘ã‘éÍquâ'Ú¢ˆÖ×2ÝÊ‹¾-¹@XA!â¿vŠ·ÿXHk2Q´¡YÔ Ô…(Ãh6bAxBDB[ÚB@°Vq¦=žŽú`Õƒ7t*Aá“%%³b=p¶Æ#%@Ø&綎jABDÌdTð¤4Ü=#…¿—Z–?>Èãv–á¡»õîJy™¿L®>u¿Þ$Û¦»: €>PRQ€AÐóJ}Iy¿]OvÆ“‰p‹Yj/!Ef@vYAù™¾1‰.4’½Ê[³ ';S)Îá)‹ZÕ65tô&âmíI{zzü&?õÇS¥jËÌ)¨7Ã/Eqù«ˆÏ„h*x‡³§·E0+Ö[6ÃÁ3Siûò’=>\¢]èÖi˜ÅïùL› wÜ"›Ë Êë¸Sˆž]YË;Ìôb LJ¨¥­BŒÉ¦97P4nF²pçkšY„ÊãŒÛs§Oš×8}ÖÔæbý/€â££kF<Z’Ë5sz£üƒî,gLŸ\?«¡7šÖ‡ÃíêM&˜5Š#°€—ùÄÿª…ÚiÇƤDL¼õräf0‚Ã^ñ[Äïòÿ럹õ3êkh&þSmˆÙ(«©ªRF?ΫGUV )¯%~-¯¨ª¨å+˫ˇeß²à&º"4èX¢rý½wîeþc-©Ùª‰‡Í …áÉŠÈ ÓÔ˜w ž:yºÅœ3øȉ£áD!b? +a²¨PŽ@t øÑ”ÉÈ)éÒ€£Ã [$$*Á˜²/€Pi [˜Ð‚ä‘0<ÒyHLcOßõ –Ž×³~cÊvà)cZ}m ·Ù$ŽBÙw3Ò 6B^—…¨œ¿Ám¨ |€,w8È`„– ngWÝÒ&I[®M}à¥Ô½F$] ø•Ð<›‹ó=õ (lØëCAÊHf;[$\zkÒ’%-H.[1èR1sF(„ÈTË×K¾Xű6¿ÌR*óWûËñV­aþDGãf,Éò·®Âó;˵ÆÀV—w[n¾Æ_Í»fɸ»r¶òö)2$š;¬i…Û\lAåúÙhDTk#îuÄ5û„ü¿ÚR,x´p²Wþ'aE›Ô<ÕÞgÝ ý ¾Yj± •]®!"‹Œr÷‡FçÑMu xçÉ@'p»KFSìgK·|UeÓ´Ñ«S¯ÅáWžòÅÍ »ykcQôHy¿ä'Ø~Ñ, œ¢:P{ò´ÚYSëgÌžŠ×ÿòH"@®g¹Ž©¿XµQ<¦´¼¦Tˆ8•'ËLÛeÂ",2–¢Eœ‚åDPV 0ºHfG#”C‰Ó.x>ôx‚â¦FÈÉ©N)Ý­J¹ÝÅc0µ©ådèã4òíVü&B5ú:¢9h»‘hãܨ¤q–îÊší~m”4Чú'Fšü xžÉ!˜Šú¢Lv´±äO @Wc¸ dánž×9¢9ñ§ÕO~3á6Óz©UûE°8Q*—~Ëö?‡íRrEá"áxµÿÚ¶MBáon—èÕi{„Œ=V’ U¹ß† àØ_¢«MHÐwüMS¦3ñ%’¹­s‚}mJ¦…¾‘]va©Ä(°¿dn©Î.váLÒbòæÛ¹€Ç$¢Æüú¹ ÓgÏ‚Ðb¤š@=9ÕÏF´m?kW~#"å4´ÞÛl•¡¹ì{o¢ý“Fm2™Ê öCwòiX{*oŽš¬ižØ–Jµ%bxõlÂh.îÊa&裌 g C"n2`>ËE2°.nææU˜ªíf‚„—MÔÏR²ÑÿmS©ÌÒ‹ònüÆóÁû0vI’<ÏcùÎ{X.pÓãjŠ¥·´ HjÍ*.·fêô€äAk8Eÿ“:F?ú_¥xíÐÿ*F‰âßéß•Š(·å%F*RÚ-øþp>Ù.$ïdhp€Dõ›D.LuÒ¶Ÿ•¬`&lv˜.-ïºnDRàì.Ö!¾w»Øcr ?`}6ŠÇx;€ò„Ë¿Á-ü 7z‚­$b%%¥%A|“n!ÞØW¥éHª{Еr!øV”Ȥ³1j†``?õq i¾%ÕS A)œ±AFõ4àŸ~½ fRŠ‘T"6m}nRb³Ûˆ$MNuÙÇÂÍóüL=é¥.5kuö†ÓQ·«nöäà”é3êÀ§Õ ‡ Fè5Üêtp‹Õέ£ÖEâÛTÄ¢ øƒˆ·æ¿º4”µm´¨?ñÝÅõU-€±›ZÅVÕ†­rz#1ø` ¾ôßï§#  øÑpênÎ áíX!˜`Ühk÷á{?y°Ðü¢Þ*7®hî8ñÆXü •±{Á Çi¸KõÎH_5^uq¸„ÇÑ„bñ­GË„‘öwvˆG¹#íò±2/e¯8 :‹Ýpð²ÛSà%‡Ö€DÀg³x:ѧNqÊßÖGm`.øRK’R+©%ñp¢ ÐDL%(< ›AŸ"!MÀ¢£OשñÌ´l‹‘3I\Xì·(J“¬&–‡zên¶ˆhw si›Ž[/sàïã/›û²È.šI2±HAÉhÎÛRv0a±q¹ß]”¿5]TËét~Ø…!ßýüOÿÌ›3unmÝÓþ_5jTyMŽý¿¦æ;ùï[™ÿ.ÁÉ¢}ØÿAM³ ~;~@- EH:ŠÇºpŒ¦-°45é }tÒäÁ°õ Žåu´‚u3ÎƨÔè ƒ†½ÅHTYˆ®4e±¿t_&h¼@å@$y“ð¦g~Lϟ۩͘ZßèÖœ¥ 8^UÈLyˆ2$ ¼„ù&‹Xº›ìÀTFŠúâ,Â0˜‹’>”c¿1…ów†û—+÷ Ÿö%âŠâäJ+×¥ZŠ^¹”ÈØRøs¬\1$Nô7Ju͆k%jÎÏÐ+dßnËE°XùœÓé+œ÷PↇÒ‰†ßCr«»(à"ÔÁ¡üëÃD©ß­ŸE~.ù)öÍä(À謹“´bOHrq\Ebr¹zZ!ÐÛŒdcAð”QÓÄû)MñÝ(-Æg$%÷²î×BœÇ+™êñ«Ì6®Ê˜è ƒæVòÇ&ˆ ¶ÁoM„;[¢aö'³˜k¿„ֺΩÒ(é…+H´,šeú€3WJLÁ"«ÊÊ<‚y؃'4’[žä­\Iò ñD @À›`jçuFÒ±{ÈÿˆAÞd d$ÜyÀ¹µàs ÿ¿ýP«[ ý<#ÊË«F ÌêNž?¥ð•6ñqEUÙà>Ðm9ûi~ʳ¨Vœçé$aúÐmŽ7 ·©a ¦6M#'8f¹$@–¼Š`SŽ\б^0H!LÛ‘‡‚êâKJy£ë¹)KцÄļá,x'1í[ÉëqVŠ¢wzgC’•yk»âö%àÚ² `¬Aòqv7™êã‰À¬x³ ØfµbtõÀ&üR(Þ‡÷±}£ÒÈã«vŽB¢‡™ U•Uç)búÀNÄÓŠ@‘ÓiÊ'ñúŒî®h–åtÊU!9 fšvò©\@ )&mç‹V¾%-,vM M¡zP­Uå:KA&p²\œówŠ=Ž)e´"üƘ³+FWnÊ*£È$;A™Qä‚Òx8çV·KÊmWJ*åUƒÙS¢xß rRoeeUùîLòxäØQãB¾Ž »¾è7GeˆýƒÇ’•E“ûCÔܦZ WKø)R´3]Î$ïVõ^£%•i× „‹„ 6.KLÊßbjÍeAvh›.T°(Uf”Ð@&„X }háf ¯¥tÎW1—#wŒ’ý!„+á“Óœ2ÛtÇ [I|8b*jø0e®Lï ‰­¬²>ƦŽa†ÏÖlB°Ù„É®±Î˜äpÿ—›ÚT nK©ì1U‘sL·ˆ†ÅG†¤*5ˆì+ö³Gl 1à …-(SZK/‹r<^š0èåóÃxçéB–‹: !¹YB6Ý+ä5(fs°(»Ò²ÐUã1÷° ÄCjääp¤=6) »j«”I»¶XÞÜä®_ÒxôîfÇìDáLq™ÇŸÍD,´4ÛWN­0GVúôTŠÀß@w¥ P1f0ëX˜ìWÉ–sqÀ V‰m¸™=Ñ"Roº 2Ë =Âþc˜&Ÿ°ò§r=ƒqk$3‹Pÿ¢1½>:z!s:'°a,M†«‘Ž ËÐ÷*pù¿Ÿ…`èèŒ5ótDîR!Nôr]`jœ °f³È’ðôQÉé-BÖËPá¨)‡3fâi$çLhsÈ/AGQ*(u–^µ2M”UTR6¬¨ôä‘ÿÄi!æ@&^³Ó‹Ö¤ß-<Äf<%Ú¢:D‡´´ â(Iô‰§€íÓVήPáŠ8„å‚-‰p²CÂEk*ªžÂÊEO8¯‘û©—G0Jý#'úG–:7Ò˜êQƒØG¢t'7)…¨µìß‚j¬$ãÒ´ôlœ\“.} ¼nñd‚ðÆ»pe·'¿»4úDGm˜­ÜF±RÃ(ˆJÈB9 ½ŽY“(³t¹Ä¯Ï¤a㌦fÊxƒïóÀÓÚòý.÷ã®*æOàk„.“Ã)&z¹{V7U«ÙeÕ/5c9‹ËN­â¥–’ªýêž•"îN~·Ó®»™á!¢ÞQ»£ª¬J5ÈÉ @*Ø4äVÍ=E\< ƒï¶=Ð&%H?g0¦@Óº0"äuî‚_bú»àÞ&Ía·‡CÑÔ(CHÍØ Gi¨N&ì†è-õKŒÇ^³L†ÇìT×1Ä)P]VF¡LÚl4rô4J®T‡Ë5[ €Q«Ì.¹¦xi}¡úCy‚æcæ#š£;Wƒ~“eÇ2Äþ¨&dæ¢ÉXcÌI‘ÕÑ"1)~¡^ÄÍv9ù1ÎfF3(Þ,ÊØÖÅ÷®z *.Zgÿ{KËØßWS­ÃÒ Š¢“eƒ‘)Di€9Ç"ÜES,ñµM°(¸”Br‰ÅÙÊñGÑ(™µ]š&¨f •œ0aeçYÑ\”Iæ6xÅÑ*‘žßÓF(dYJ€Ç­³¦K ÉF4p¡\Â9ó• ò.¦T±PwñO±z0¿y.ìî„b½»‰» ¨Rü6d””ˆQR"øqKúó} ¹'¬/ýK:ŽÿÊ,Œe¤öƒ>çBL(+”äXV.%Œ1åƒ3>ɱG֚ʕÖT‹K¤rtRgÎ&ƒ¿aâ%³£ŒÝp¿8åÒ!ÔúVªB©AàÀîÉËì4Û Ø²ƒ‘„¨'òŠÑ‡Mò²Ñ7ƒb ³[ÍØÚqŒðÙpü·ÄŠñTÞ­3…êêÁ1Q¾?éeÎý \®Ãb½ÚßæVgpv”?H R òèQƒâ£ ÷ˆº4El<+`þ¬Tzn<-ÿ”£”AW¡ƒÌ\ÅÙÂ&fÇéϾ(x¤WÞ{µJ”2Œy°"×XnÔ.›¨O:a ˆÄÁøESrxíEa@ˆã5—yy ¢ÄÓTU ­¡uuZT-9æ¤ia³Ý§ô–!+J/o4A/!,¢Z8“„lŽj¼éºPÒ ÆÏ íÜó¬wê k¥®ÌJ]3XCŒø/÷° 4IVe(ö%–«ö Ò‰ùO\r¬ç"ÙCœé&Lñæ–UÔZ8ôJ¸Á\pÖ¥¢Ó*äèžW0›V=kcÙ¥OÏ<÷/:„µ™ën¦½Ô¼8XwA¸—0X¨Šu„hx2Rœdñ6-ÎaÛKñ@¾ƒSRE;á¥ÅCgÐÑ2 ‰uÍÑâIÌ®ˆ=! AÇPÊ#`É’¼uˆQöš*$˜Uò|võ.Â$-ð«Yäepû‘ñûúÃíe/ÈZ0л¬þˆÇLþ­—ŠÈ«9GFz´E^yUvMÐ0Âø7¤”š¦…¾î÷„†#Ýþ-:ñáüp"Š—xºÅ9µ2W¤ToÑÆ‹À£å,%A‡uD»»h2œT••‹ƒp^îSéø11ð‘q ,iÈ%š½ò£*L® †êl2ÏTZFÇwN¾Ý°#-Ú&„$5šÇ|XÙ.@hˆ›ÉRF‘¼3⢨`Z¿% p(HTM»¦½Sþ#óNïJMîÏ Õ? Mh=K"Ežª‘±©5Õ\؃ŠÜIgs´ °Ñ:«1ô΀¸¼¥¤ü¾BaƒDntÞ#ûf¹~m ÂBg8|’ÂBýT[¤Œ|­üg=4…·8~Ú xŒz£Ôj˜ây1%V8CN«˜tréòšPOó@Ë‘µf8aª´þWN$‹¥ ù™–ŨVÐIalJ² q·HFúV¦ßÖ¢£ðbÁÀ7?a`WÂN¬;¦ÏXø!º·Ó>må)y=OÀ´F+;Yû Í©2'‚u+ ªïÇU.—-çL4€ë;ŠÒ•ÏÄܧÊNU¬!ß×y2ÚW7e[ óeÆDíæNfUê8¸TÅòñçFî Ñý)ydQÑJ¶•5ƒ3žUÖä»×àÜ}ó彆‰ëÞJ:¦²ô©›ò)†sŠÐ:1- éÂc9PñáÒi›·”ê€tË?ìœîˆ#h >5Ó#ú9§);Áõé&†ðúNWQsÀtò·L~”’R¿â!Ýq Îj#öí ר²^‚*ÖF`«Ê¦¨é°ÖŸ$— ¸Â3C^v^‡Aª?Òý¶ªëègöãÇ7Sï\~gç°ùh‡-d†íë>ÿ?d#“Ì2ÇàyDwÊ}ZM½vs©·£¨—­¢BSõÕиÔO`o”ºzͯ—îe]™%žA÷eº}.Z³itÒ él!“»«9÷RWôÔ«ösÜà¸ÕŸz+h9¸uaØ/œ:*7QÔV. eï†ÿ16vj ö"/|nœU9>„)-â[qc’ÇnÛâõ6_‰9€œ—Ϋ;x8²`k±Þq*>tž³ú²eŠ Pìõ -TQ#>ò÷Bw_¦IÁålÝ̘è‘Šô9BL/Ì!& 4bŠâl—’c»{éØeº½ÜS±i ,ñÞf¸Uðø&pŒ±\¨Ñ`Á ‹zºMuBÉ2˜nÈhíCÓN×Ñ5K±¤#°stKÜ,Á¶’I‚,ߧ¢-Ê«R~ÛÍçJÁ gòXѧ2’ê"¹ ×gw< ©?Øp.ÎyJ¡&öXÔ´7Ä3ßÓ²SÊ K$ ÇéeˆÎV^i€cŒùÛŽ•Ê¦Û¢5¥€Å¢è(7ð/ÀT‚ØÓe œ-É.ÁÂACv#)w»œø ŽP;ý»‘â3_wÎ7Jݲ:Vñu;VQ¨c[Ò%gß*Ü}‚Ð<ú-S˜´˜ºæd.í®(-y-ýgìÎÊõOi!nžp‰¤¢Ö.3zp»dÌè>¯JòX¦Çäó¸K9¤“Øjg_zh‚G/`žÎ—ªFa? õY¤.Þiû,3þr-àÄÌÒ}’}#÷^Á®!W·7³]¶ «xsS©Œs©—sÒ© ¹×å– ¶ýôÔ«A£"‚5‹Ã˜4r4/ºmÅÔ™0ê)& ‰ÂK0}…|=äáRÑžËÓƒàæ™-§BßQ˜çäóÀ2alÇ&öÑ_l?8XrK[às€fÈZÈm^ˆOꪷ¾Q¬¤´3ZÝoGxÁaGÄóh,éÃxŸŠ¼§ºº%•.µ•õÀýWâ$ôñq2Õ]ª•ñàq&¡áRÖ™;-¶ÜÀ2ÎV ŠGÅ›œ&¿rÔ@Ñ3éX¬”>(µÀµôÔÐ; ¤¨vHrJ ŽÚäƒÔ™‘Cr·Qeýú\Nµ@Qz—n£ò±6¥XÓTôM­àž1+ZÚð§¾P……Á]ˆ™bSQç!”‰Qø÷X©'«AU¼Ñn×ä±LÃE‘9b!Cª6ÑG¹ímžÝ9¼„mWTâ$¥¾Ž-ÓCÚÈ:lÀav®ç:2ÁHêÙÌŸ¤ç¾:L›V˶Vxˆ£ Ašè²w‚’nKý‡€q˜RœÂhÃÈò­ Àý¸T¢¬P9Å$ˆŽxƒÊÏ)ã"n˜Ä†;[âmYF†jÑ,8w¦!?RâÁ}(?HÀ* Ù°|°‚Ø KÆÙB#ö‘Ïï^zä;ESÀ>u´ó9ëe¦ÐÃ9µxY˜J é²2è$6;5CÃ(t»˜`NI ÌñÅïG<™@ƒìzOÒrSÚj¸¬Bj Ù%!24Æ3ZÓÈŽ°–Q€ˆóŠ6Jp`(ŠG‹F9h3E0ýEÒ¯¡ÈZ*âYÑ¡©ö$»ú©µRdˆ7u©¤W]îZî¼0CÒŸˆ@kÈß.Ílä ·ÞB'ä{Ø1ßÄ‚—§æ ¸MUõ tz„¦vò“jXæ¸,#’cÄüQÑ16­¸`±&йKãXrGJûhDœ¶*…%Èû©>osð 1Cù Z(…4(5Ê "&aënwngL#ä§ßCæЮ- (OdÃR-QpÀ¨ª`e^E©Xød9Â~Àcú –±•X|îÐõmUMÅ ,@¢¼gkrYµÄ’‘öÎpº£”²- MøÛÆÿ.«©vâW—U‡ÿø­üüdÆìÚº @@ù³I³=Þš)¶ÒÞæ‡ÀEdeðÏOÄ[Ü)͹{,üpµ¶â]¦»`¸®t bM᮸Ëi§Î’q€íff²úê n. v.¹nbp¹K”ÀnÚç3ÅAÂ)Þ!¡nPlÂbJcŽMsM—«¼Ì×2Ä(âÞ“ìn*)6y‘êçŽX_^ñÉîòŠJÆŸ$Çïã§O»LøXüã‡ìMéL±›¶…" NG¨ˆ¾œÝ6 Á0Ñä,‡„E~~ö­íÿÊò Çþ¯)õ]þ·oågÉ¥ˆŒ’@ãmãÕTmWËá„ËÅ÷Iny$éùlÜ.{Ü®"xHZƒ–€SHÏ&ñM[qèõ¿|˜ÀùŒ€ìÝÒ;ªÊ ¬fÞÝß!QÝýO˜ÁÊo|ódÿWržÿ£FU|·ÿÿ÷ö?ÆgîJqˆT ¸‚/À ðJè%åß1‡ÿûûßJö·²ÿËËkªÊçÿ¨Š²ïöÿ·ñ’?š?:JClNmcP¥‹ÃbD,—~öaLŠ.CŒÙ;R¤2Œ§¸ønü8£Â_î/“_¢(êÂø®Ü/X…ýݒξÂÜ™òB¦ÉÊô§>2YéOÐ3žtÇÓ`ö¥OËàS×Ôú™Ú€óñ3 Âhz°”XÚ(&Þ¦S"•ìÂî3ìïà £xÅxAj•Çå,Ÿ[S·èT4–È­ÊFðÜ×L{l¬’†Éî,bX‚»S'FYϧàj¤_]ªì„ƧUþj¡‘…ó;ÛÄøkà 4)ÊW&X’:bÙ|…|eé71Nú*‹À¥è7HVÈ6¬ÚRO3Ç`L8W|0ÆÞ >(¿±n8^Ú¿Œ—NJÊ{éò»ÆšL}³ÑDs•òX7Šm›“ó}©©í2yÇ›E¹–4ÍŸ ?€Uó\¦þN§áA ضja|Ob…$kxI<ÕÉ!¯Àl¬Ò`ûÇz8™1ƒàæÐÁŸ–éË6‰“ä”Þ”kƒÊ´ƒy8h†[åÛJ¦”ê’²Sø@OCPi‡­‰rÿhY—œ_Ø›ÖQÕâk5SMK¥ö.Ž©¦Œ+Ò–4(×;àÚé-Å;c’M…kÔܦc± NÏѲ’t¶#KcæõA6É <)ÊÄä­zA5µ‰ô]QtªÐŸ£È;‹©@ ¸ÌšFmõžÝ×JÏ¿t%Ïö®m?dù¸MËaE©7]©Do["•!žV-öÄÒ$úh7†­¨yR–(¬IvÂaGk]O0ù+å„¥yN«ü£¬,2B«‡—…ö±”zÊóÈ¢Ž‚”ô•Z³¶Oo$jW縴Ú(.ÊÑA¥n °¿¬ €VJÓ@/˜u[©H¡®A  ó,M‰¾ÂëŠâw-]O7¹KJJKÜÍþŽX¬+o5–rrh:+à× ˜Úƒˆ2¦æ0¨*â:`ÆJ©",ÄGHc†C¦ù?êëúÝO!ù¯+Ùöl£ÿŸ²Š§ÿeyùwþ?ßÊÏ)sfMÝŵì¹]¦O«›;dÈ6 ÅïKwü¾øùˆ_À÷ÍÔ/Ì4¤Z3÷?¤6šj‰Ó;…L47Žöýhì!Cv›;½®¶qɦ·W7§×?öÇÝzîÙþ{Õí9ôä…Û´n_<òþCVO];bö/öºøš!7|ïÜíçL]ô‡yÝ¡î®+&ŸöÆgÏòìú†ÿý««•¾êþ¶ÿrýúÊõ‘¿ÞàŽ›xáƒëîëù-¯nH®?{ýÓn»hݜӇ<±íÕÆ}|é¾ÿºeãågÜ· éÉÛw9oË}EÃ}@PâÞGFŸ5ü¶65œõñOwÛä>kíG•g¼Û‚!Û]7.¾v×{ÆYyKéGÏ®¸æð‡‡w²7qÕ²ÓsVÆŽö͹mÈquÿ(¹ñÛm¼wíØ“G1?kÜE×Ü¿é‰ Õ÷ »yÈ£¾¦áÖÐô#‡ý~ò‰¿}åî›âgoèŸÅóì†a[îê=Óµæ¨m†\yÓ3+B'Ÿðý;ž1÷Û0aÈMmK'}ääÇ÷Üù>ûxý“çn·ñ–²?¼êú?]7dˆwÅõ»žürÃo^»`× —6ÏZ$j7Ÿ|z»!]ϼôùã+–ÝñÝןºè6÷§×ݼ×Á¼ÿ›Ÿ?錒ä;©f¬¹¦ø¸GZ}祉\m:ñþË7ïüõ–+ÆW|pÿk­ŸõÆ Ëjw9hó´ûf¸|˯>ïX¾÷Ò/W^ü`÷&ïóÏ_þÇïZ·îÊwJ^Ù>lùæß¿3ö‹SÏݲlΰ3Ï;ö¶sÚNöo7ÿÙt“¹ßMûÞñ^¢ã‡EŸ/zþÄýÔ~ñþþ¿3?¿æï+_}úg_¬¸£´ôøOš<üªŸ²êè 뇦Çï¹äƒ¥Ï.1WôøRv×Æn¼å©+ïŸwÛËC¿|ò¼}ï»òÞÒÏïºzÁÛ7á7´]`Ȳ5÷<´îö©Û_úТM¯ÿû‚+Îô4½±î½ÃX¼~ÁŠSj<°dÁo?cř۫sOÃâaC÷÷ØWm{wf÷¼¹ÃXõô˜ê>ZtôÒC/;îþC·{éÀKLžµÝ%3¯=|îíµ×°ê¼ß|ð˯Øñ‹ýüGÎöþéO»F7ü`Ïa§f?{òÓ{¶M=:éó^üþÊÕ÷Þ~öªç¹ùÎG=vÛ)w¿·~eöå#’§Ÿrì{Gºÿcß°£ÿrã’×gýà•à!wý—Ý·ÚýÙÆŽwŸ»cþI³þ¶fÉœ;÷[¸ßóOœ¶|æ׆6žqëóüë/p²êãéž^ñÒŸÊÛ“{œ{ï滯ßá„5§ ÿÇâ+þ½¢«}ö‡w?yÉ¥wŽýW颓ú—{Bz¯—§ýãʦ5ÿÚ3p×iÏ.ÞÿÉÓ"gŽ>{ÚŸ¾š ôL›¸øÝ“·ÿsÛºcÛrÉ#¯{ÀQŸÝµiï¥ßtÞ{S_[}Íû£Î¸îŒeíîzÆ[‡¾U}é¥Ï<|êÏ÷zpî—C+wváUG­Z:èô;‡¶ß3Þ\S¼ø7wúÓ—žùòã~ºy»ñçŸèûõä—Ž~r›‰?iùÛ«~¿w÷ü™+;Ÿ?à‡ÍùdÁ‘ÝϬ<þ±/Ž ýèg·¼vÛ…ŸìÒ­wíyòî¾üÜv7¶\öî>ÏÖ>wõö‡-xñrÿš]¿w[õ»›Ã®—ß½àƒ§ËâŸ}ùÖŽÏØ´Oóò§›¿÷jãí;n¿Ã´+÷Ú”þÄç§OÚ|ÞÂjwv´ÿá¼¾¹~ÍÑo¼råì6^7¢üØ —ÅRÏÿhìò v|{þ%/´œôèÈó&ýäбfé“K#o\yès3vX0óªÊ['Ä:v™|Ëè½ÿºÝÆÖ®>aɪ»gOû·ÕóO®Y1«dþÛÏÅ#÷ýóš1»÷_ÝX¼úì—VNùìš#Ÿëùà?eù«#Žxî’?ÔŽûçÛ›÷-¿pïLÙ':öœÉk‹ÞùâÙƒ¿|ó×OÏ_´vâŸckÓÏìzFóN[ÜÃÖ6ùß{ëíþuñÝ'í8>8vç7Nö†>úç¼yCÏoÜrùg¼´i»»¯1?úw;gÝÚ w­xâ¸çNjøÙ˜'¯ù›Å£¸ul÷ÑW¿¿æþŸxΧŸrØ3ŸïñüAsö¹gâÓW>;oi™ÀìÞï:c·èn¯Þ°bÑò’N?é®Í%o›¿º÷ÝwÌ 'fvoŸõgׯÿõó¡ûœ=å/ñÓv÷Ô©lœ1áÇ+ÏÉÞX2æ‚úƒoÞp÷Nç^±²xÃÃκãÔí+?wûÃZ>}ðÔÈå¡Û_=aÙ{-œyôêþ2~õ¯ßzðºK~VóÊU‡|~Ï•(Ýá¢Ã*wY¶ñß×\üï×/Ù´úÙóyã%m?ºãÛÙsÄÅ[öÚî­ç½v¹—\³ëºÐkßmŸ³KÍš›Ùø¶Çš‹þáÂÎ;æùÀšÃŒÖíÿÇãçÝöØ÷Ïzt¾{þÔ¦§>ºè’ý—ìµhÓÿX}[è£?¬¿çÔNïʃ†¿o¿Î·®5nüëØ÷"'¬>Ío~ýù=7„öûèÀÓŠWd÷þó-g¥ÌýëŸèZUuÄÑÚøo.œxÂiÛNÍœ[u›»o8â¶ý>Øpyê…)÷4]çÙñíÝcÞ?Á~hÒèçßþÞL߶GcýÙ®/\»qc]×¢Ëöìúµ÷¢Åß[_œ´ÏãÇg¸=üø-ÿ¸ðá›°§ùÉ„gæœtÊMU=²n§šMo-|õïoŸpmjÂê÷w<ëƒÿVQäÓåM›îÚ{ÍÙSÏ\üJLJ]3ªNÝþï7^ÎòëŽ8¿ãážvï÷Ŧµ»Nôº?{;¼oÏ)çÆ~¿¬ÑkºaÚm‘?ŸÖ¸÷KNÛë M–þíÓ¹•.»ìG•/òì¯Zî«Y¿ö£%ì¼lº1i~Õî;ïóÅO_*¾û¢³:^|ài_×°žçb»µ|ØÊ'Ÿ¨¾èÂöŸÎ_t`eÅÚK¶}³ª~ì±çl^·V°¨9ïîùîûÇ´\¿zæÛwLâ좹·/¼öæžÕÛµlMbùk»®?î9ÛŸ¼ýüÇßzñõkZ7,ùü×C®;àqï÷‡Î¾ä‡“wÚòÌCߟyÐ~/½53´CQÓï^Øí¹ûÜ{-ºö¼Ä£çè1Ønkų‰ãß[}|í ?=º~ßݶßòôíW®½ïþßýÞ%{íŸþ]çO·Œl¾vßWëë™qÁÕ§|zÄò™c«ÛÊVŸuíð 7½yç¿K=?øEsÇu_ýtô£Ïî´]åÍ÷zíÓuïöôƒ=/Ü°¸²4pÙë¯ì¾eø¥—Þê—/ß2ù®óv¼÷³ÏNôyÛˆÿeÇß&îY|ëá_í}Í¥«öÙîÞ‹‰ª­ìÞôàù‘ƒßÚü}§IWûÖÞúÀ¡—¥Ï=êŽÎ%]çïü§‘3'TÜ79þPó¾çÞxðï_{ç”mzF\õrãã¦dF}µÃˆ-áòlŪ]ÿí]yãããÿê¹eìYý|çmkvýÉÞ¼öÎ^‘Knq¿xð¡Õ—m_óPçÓ‹=?ñøêËÿrô™6=5¿õ¥ò>›õÒœYå;L~¶frí3—54?|uê­ÕÿܧãðõCÞöµ¿Ä/»pË%»}xËóC†nüâŽaÓ/}©rŬ?^YùÉ%ûž¶Çî .X\õxIMÓ齇V^tÃùo¿xÔ ü­gÔØcS«²ïÏœ{`ÕikÞ<éÅnÝfÙõ»=Wçyò‹IÝaüòWþßm»ïÐE§nüÁ¢'œ‘ÙýžêOž¾ðwUŒl:cÁ±çlÿ—³6ŸÚ\úðŽW¶áæ'_ìtäv'œøØ'{=xÄógöº/Ø0Óøå?ÏyµnËÈ3Þð†®ó~§ìäso;ñú5ÉwÿË;Î\yMxÇ·oýË™߶`ÊŠôÙ¿YtãiWÿ圯.»ã¾gb4Œ¾æƒ½ŸïÖ³îø,rÙKGü2¾êoWŸþÂI¿¸éÕ ÿ4o}í«ßyÏ>¯¶qÚÊÃ^uãs¯­|'¼êè3çœ×ë}ï'vÛñíûê?¾çOO»—ª]‹¼+³·Ü¹¼û†K+àm=kóqm¡yÇ÷n™QöîO]ÿøû©k.ØfÿÅå>ôúŸŸö`ãƒ~ÿÆ©gîóÁ÷æ.þÞæužã‡m×}á#{?´å[â—ß}Õåo®6îû»ؾó¨uŸ=÷éWž~ÂÔŸ}â ×ðß~yïÚ9|cŽzhÿ¯8r|ôðGÏ»¥úƹì±Çîä =ø\í’Ðê†ýyí÷.ŸÚcϳš~}Ô¾«Gv–$3×ÏzµjhÓüñ¾/? ÇsÍÐóÚ箼f­ï,xàªýÙ¾ßÿבÁ'š¾æåýÞ®î¹æËÆùÇ^úüäËŽ¸aˆïϯxãí××]¸ôÝ'×½zñˇ.x¼¬çã7'Ýy×äÇ>:¢èËÇ.5OÞfÍmGl™\¾â„æínŒ¿ß3ëWÓöݺÓyC¯mY?öšÓ“?Û¼bèæÖöÖo¹û½ÌÛ7ß÷§«Æî·0ñãýö.;ÝÓÛvî°qwܳâG‰ î~ì§ë~þ‹Íߎoß¼pÇÀSOÎzÝ»Ç>Ë>[wd×Ù;ÿhõ’GN({Ö;ó•“£ÞÏ.øxõa{_ÿì#‡|ôå+½þöå×ïÝE~mEÇÅ7±©öÞÔÓˇ¯¹²rþÉ·. óCwìöÊõ-öqoë Wö®¸ÿ{oM¸+26qèÞ{¼þËËzï_ÏÅKz~Ý‹ÏxÕÅO=ôÇwÖ>üÊGOíü³îüцÃnm[óÞË{¯ûº¥GÌ>4ôæø&Žz|ÊI/›gÜÚì¹{ÿÓÞ©vŸó˜±ÛÄÄõŸûç͵ÿ~¢{ÊèQCkF}¶bÝò—ºÃÑÍk柺ù×ßöÜeH× ¿=çŸþãçìgóuïnÜíÓ+„ž‘i»ïೞÛÁ34‘úVÇÅžkª~óZå*ï¹¼9ãô붻ÿ¨£;_,=wmbåYWøÕCó×–‡Ç7^3O_1ä¸aWyîÜñ˜÷ÝtöeÅÓ—½sâß'¾Xyò‡‡Ê i½ã’®{¶¾þþ¡‡?¹«7öÌ=Ÿ®yiNï!ËkÆïZ³ê…ËçýbmªóÕUWò‡eó¯ëynÛ!»>sÄÑ¥(ûÅýg—Öþþ¦½žßÿå þuŸC…þøåÚg—y ë˜?ÝêÛOþ´îü/~_>êƒsîݼû­}ŽûùKoU¾6ýçé½ñÞOn¼òö¡‰cöøïÞÙö° w{‡|ñäÎ×î}Ï?˜SòØá‹ÒÞÛüãÙž5ûÞG_¼ã_ïLþxLñÏO^¿÷5]3ÈÝû–ÞÜzóñ×ïlÝɘ†%Ù²{ÐQdÅVOÇËk)éÎá… ’ЦAÊVÛºŸý­³Ô^à"ËŽÝÃÌt"µ£êÔYŸóL”Œa4h—Š¾û.ìAÆþAÙËù½|_¢¡XûG¸é­8‰ÔÎ뀦…ÈÂ8s°¼å™8|©\ ‰£~+¸iýdŸ3G91¡ÉxÍyú";Ï«QÖËݯUÇyöm •óÔ€ËrG8W”"bÂуúeÝóWè«ìž°x¼™^´¥«ÉtR ÄŠ_HÄ;ìçÉdD‘l³‹WÛì“òñU¼™©L‰-Ú§nÕ.ní‹}‰&f¾æô²¿‰ÎË1¥ô —x^œçM6ü6XóÙ‘Öê> ¿æ\éy¸÷_‡o†åÛ¡JÇ~ýrÚVüRáh†ûÿG19£úb ¯sÊ4ñÊRTxASaN\ 7Y¯ú‡÷ ‚­«îq†Ù1+KÛ…ʇl×oÓÈ <£]žþs‚žû¡ì_† ìáÕLÛyæ yŽW/ÊÉ +æþ9ÐHé7sänZŠ8±ýì'„­ÖÌ‚€Þ.Ùç18HóáÓƒ_¼gp›=½| Äk^Jªª2_ððìi/=ÆW™šKÁeÅqòžÒ.ñwBˆôý*Hðòû¥<ìÁ³w0Œaí[£öe6ôª‹Þà:Ÿ”Óât:QÓ×âTâSèTE÷o±ÝÍÿ]y#8|çÒ¦ž¼±|Ä0}ˆ¥ƒØ ˜6¬Ðµ†dÜ×;žPóòDÝÈå­ssLÌöãŸMN•éWñv’½%!'9²[³Gi4ÝçµôÎ%‚üz¯˜+’ ¤þ{1y"fqlæ»_PÚó $íö¾Âm\þóë•p¶ÝÓŠÅZ¦MU×kÊc_¾Q¨e­°ý*pÁˆÆOìZ ƒÒqF®ÕÌÝV5¼2Ö¶º§óP‚ülŠj~Y…]¥Å„²Ž4l;ƒK=u%ÛÙU&é ”cq[¥åÉ¢Õ0-_´4Ãg/Z³^ .—Òùt2ÍBrí ¦Žaf=™krÑòãüTˆ‹–¦lj3K¦uŠ©È–øÒi9N‡b‰fV©Û›RϲҗþÇêööé€gë·6¶î»þŸ¶¬âÿ>¯þ—6æÊ… GƒµŽ EtÊï¢âŒ‘¹ˆ{MüõQÒƒ •™¢Y £6^÷ë»_f¢¡L!Üð0*ǹ™ÇAÛÌ©Æc)†‚r÷Uê5ÁAœôšÎÛöÝw2q;^Ýâ¦LÇ(ÜD‰ÌÉ·Æ/×£=ªtw.óæcÈ…4>ÎUšNÁê„b@A’2±±jˆô‹üˆWÙ0/§ÕàRg—Ì£ ‚ h?æz¿¼|ò÷h'z.ÖÿMé=7. Ü*S%¥4nG2}|E e쟓WŒÂ¼O £O>¹¥²ËáÏTUv_PëîS㞸edKTÃD ¡’+ÕàlY…J{ÂkVa®§!$ýê̈å‰jG#ƒ›3àÚ:£ª Éa½CúG1Ê9ƒ/ø†U½Í1ÇÀ“à‹(;L-=Nßò6ŸòRY#À—·#ý³HìôÈYÛ`p¬'šŽÉq>y y‰×çý7X2§@ªž±¡…1—ªOȉ9¦l‚dG••…öa®ò³â¾Ã$mc§æÑi:ÛØ"¦Ÿ¬naÆ ø‰à •Ò×Uõ1AArïÞÛ·ocˆ‚ë—½ 8:ÎHÂÇù÷€_¾wðjÿ‰Îla-±ØãÍ|xÑR‹ §"®.‡½³q9,þGïå·Œ®¢ép#Éà£,+A3·Ìv¬²'Nðð®Ñf_!΋EK¨íê–=*ÙcìØê¨ ™Ö{YÕ+¼Û²šÄgMJÊ„ÛÇhü„¾Y,žî ! ­I+’Y1šõú©ñ6~“_V1“ÇÝf½µ¢ÝèV°‚.‚}Fb³Œ§z9óA•ã˜Ý'ÖÓщX­Åµá“N&‹u8Œ§ð=Ò‘Ögñ2_4á_¹AÔ÷£ë.žÑƒ1è‘̺f Nˆ‚!Ï™fš³&ÚŸg£æ7 ½nÅ'Ðë C+²ÿ.ïA !JÓÂù™/ H9¯³)ï4žn}ãPFœ$uƒIq„êÚ Ï‡6({nòÈMG•ª*ZâÍTy€f¦,È<‡¨ù-¥&nGßàú Ðs±†`'½%æ {ÈÚÎ\"^Úû™>B 鵛ܪ*žž ¡}h–çVpþï£Ç¼(mî­åíèàHfo`X•Å¹)]I>‰›W='s»8ûôGÜÙlf?òÐWMÌ0­~êN'å(EîEÑYï »ZŒûSœáCM…4y¹6“ðÒ6[üÔØ°;®G?çF÷5B7§êCÆd]NNrTÒˆ‹Œ¯Tg­+n†Y†hZaeúŽ×ô 6áix¬i8èƒN¸f *î×8ÏLUZ§,¦¹æèÊFÞ@\ÃSˆø¤|B@ÞB±#qQ vD¯›{}‰Ï©wôˆ‚:›Ý¸ŸòIÞdÆ×DM“äŸé“½ƒ'{O÷[’Ë[ÐjÇÒAyžËéT˜ Ø1IÌø`ãç¬T‚€©ü¸ØR}J0C½3½wp˜”Œ¬דuéÀn>ëŸwŸÐ™¢ ï˜TkבEªJ0i¢D(n£ià{$„P—øx.¥Ä!´ÜÖ¬ì¢Æ ææ“#§1Oiä%D´u®,¦TÁbÉu«¨™Ç§q„û Z¢-!,K«éãÏ‹Ó³‰ èœÄ^á9•Ó1ìkhB\ñãªâ¬ö¡E!M‡•a”Y׫«Lž’=@nX0ætv~ñ[·Œ7‡iÝ`”þh>iù‘0ÿ(IG«#Ûê:c[°~ôÍ7רóñ§¡X9uÐøJbôÍâBHòBB2pºTNˆØŸ—¯Ÿ½|qÐà Š ¡Ïç–8ŸÎ‰á•Õ ¬cÂJmp"r 4ýmrR—º#Õ–€%EJ’°­º¤£4¼4{¡Nø(ㄸ1&”=YïÆkÞtÉ¥‚׃´SWk×¼4ø®ÜÑ·‡ÃVÒOÝþþ`°2ë”/ gœÀZÂ3žœqb¿þTP’¨#´.Á†àóTÚÀœT“bÏ@Ùpž §â¿—&O õ¼#Q×Ú)‡áŽ4Ýni\•ŽªØEyýý•×¨âBwÂõj+tC×ÔŒ*¬ö‚[²Òõ̧³û;Ó•ÊqqZÌê‹×—fÞé.Rò»ïŒœ½™QUî=.q7¬}î˜ÊNô—·ÍŸö£W¿Šÿ½<8Œžîÿ²¸½Ú;|òsÙÓ"&.HÉëÒ„º±÷â÷Æ\ô•.ñ67ÓTŽs)³õ£fï$ŽÀ{b‰[²Â›ÿRµf»¬g¬î¥ÔÀRšYß‚lF+Œ®ƒºX¬šzZój4AÔ“mòš¿-‡ Œ—º¨jÅèUÞS16Ùg”|» ^œSO™Çõk£{ã­y\5IÛ°'Å©Id"EÂwø­þLV1\ ]ÏUÀ¡°¢,ÿ÷§Öî$#9ÿZì—H¼i-oYíø© ó±°9ñ wªè½®'¶»Ý©±31¤Ìlh©i)Fa×›MR7>d‚ ¹uZ”íÀ`Z7±è*o¢½îZйCQÝÒ¶VDn:%>,¹þ’žÌùÊr®öhŒ®ÑM§»Äíßmbý²;Usöù‰¦q,ðúj#2[ÑÎ%vŽüôwÜ‘Ë°‘˜!ˆÂÝü]Q(!L-Ø2)(>h™oe$ܼjùœ¿æªj礇AµV »y­9¡î‚ÇTEÖbÇê³Ö¢p[HÆ—G GÖˆskÉŸš?qÛÞsz¹Üæ"g+ºk´ØIœ&º3ZÿN¥` ŸÅ—ð±·(ÑP`q~>š\îº*ÑWÙ+`é6 ­Ò@£I¨§VËݬ5ìSB4Q :í”âtX²Ýϸ/{žK°Udd!åœK!jhìÿòm~“ZšÆrЗoÅ·_Xü TOõ‰\^Š È.Áš©àø»ècÙz^Ç—E>è/: ÕLÛ\€Ö²µå Ú¡eüØýì˜Lqll©¤š»e v.´g¸åE¾µÑÒòß9TyÉoe4Ñ6ÆÞr\Wp’ÿϽ3r×¼a? yøß›Û<üïÍUüçgùÇñó±]ldh•åÎò»á zÁÓÕ™þÊÎ?AŸVŸÀpÎùßÜÞró¿noÞ_ÿ?ïü› aû*o–ÈPå>®ÄO½Šo"WŽ¬ßd¦¶³ýRî?¥{&‚ÝI´öIöÜ· uF#ª‘—C}Ó–ÐeS±`\òÞœ Þä—í(¥.í uPw½³ƒö”èjÎ(©R*ý{ÈŸ§¨Òl· 8 ·¡w‰èÿJøVŒƒ)7I Ú F8á°X|+’Ò7õov8k:Ý&Tp—ÀXÍP¦1Ëu/a/ UÌ·JAO°¨ŽÿÅcs[X﬚lŽ¦a–àýrKË¡E„qR‚'‰ÕÌf¬†ÆO¶âИøåý82=MS~ü Œ—ßm‹*2ªÆ(ë<”uŽ¬LòQ=hGÛ8·‡Q9\FgÙh”Ùeœ;ˆªi¯—ç}vãïåÒÂëéÁ”¹¹ž[ž1¦g3LÝzÙa™·ˆz›“¢:—|yræFZäÉLnµX½Nõ¼xM¿õJb 4*]µ£€Óï3 -¦7ññ4½E‰„Æ')ÇÖøiŽ¡qe¹)˜Ûïãfc4Äq;4ÜŠ¦GÝ­™_ ¿=/wÿ/:-·ÞGÎ žZ£„tåÑx: Œv©!†Çå‹`_¨„àÜÿæá¾1`ÿÿྫÿy´¹µºÿ¿&þ?ÄF/tÅ̺9B׃Ö.d¡[„‹(¤‹¯â”~®ó¹æn^0çü?¼ÿhÛ•ÿ·VöŸ?Eÿ>ÝÆa™y&uŒ%zp›™ 9 b(ˆ‚¾LÉ;™{ƒZ#Â…U»øNÃÓ®~xѬc@ñ«¸Š¿±îÌm_*; ‘ír¼Åh\ 1ìËrŠBM•c°õ|œ[w:ÎÇê*Že.³¢þT·I?Ÿ@J55ð¥J¿ÊŽËé¤fn^s "gCS¤ÌÖÀÄÓh Áqt0¸lãäÄÄŒ‰ˆiU‚/2üNGÔÜQ$¨û=͘ gâ–Ž‡ûø³Ë<¾"_ !NGnô‹ÒJUL(ÑF3ÎzÆUèBS`äÄœ÷ ä™þÝs/« ó£‹&C_Mµ)VAŒ¹‹gà¢SAlØÈ[}Šª® |ú¾ñ-UÄ4n ˜˜Ö)N §76€£B³#w,ù9q&òÖçðØ .®ÛB§ 1bñ:áöˆEôŽ3„J—°s!LR “¹R:ÜöãEjrèÜ\䧇†¡ƒ"Á[¯ó—5ƒh~8¬¥+œˆM?ÕáëzJù»ìÜ€X0š¤4öQ'rößkXÄ~˜D{ð¢jh¿Ãu%9Äql=Ó |¨'Ž5Ã~üÖøè6vÂpèR¨ I6ÁgÏž6œê¼Q'ê<ØÒ~ã Ä ÿhLäÞ1hDݨë´À«Žhò(ÖÍŽ]TåêÜKŠþ5ˆl0U¯iPmÛ3´}CÒEêˆKõ¿\žl’;Ø~Êîø2ÔÔ/K&·½Û#ëB1þ^«u7Û¬™‡ò–æYKGso³ñ0jtžî¿z½ÿd-»Ñ« 1DÅ–’ËHʤÁâ3,ÈÇŒ¢7ÅÐGã6W?Žž‹‰XEÖè¨7j¼ˆM‹˜5ÉÊå®Hiˆ“$[š±œ‰¹¶5º!MS‡púûf-\2³¬:m”LO€6ñßlɬC^X ï™{Í$8Q»„üÔ×j6J§fêZT½ò‘㓽'ÁQúŽŸiÍê¶Ö®?:ã¡ 1¦6ÃC´"~^kçnmÞžâöR'âvÁ‹\Žqޕסàfcg÷GŽñ92ÅœØÜ‚°Xc°Ü'uÀ¤1qÖM‹:X[Ã}׊óx4ç!]ÈÎC}ç:/oq Ø×ôBh 9‡ =aLÀSñääL ‹‹b“î)¢’ öä×b}7ZxiÊ‹|<.À^[M)’Ÿ}.L?ˆQY‚ô®¦㪠ôŒÏ}ü"ƒp&t'Žð5Zã 0(qdÃ-ir€ˆ'b ¤%yÛò¸ÈDj´Ç£áî •Æu8¥"4¤ %5lÁqð•Éþ°IôJ” ç󩳫™µ;ÐA7ÄR°ŒËÖØiÎ.ãI ~c8)ÝNÕôB5ÂÝ2 “3h‡{;xœK É5çÊ×òuôt!c¡•€¶ÉÇ7å$Š„:Þ–§:%üÔT ÞTÀ±EØc€OÒ¼ÅÝu’Ú¦ºÑ®oŽ²šjEIÔtŠTÙ…xïX§ÛRØÞÍM~dŒÑÞøqy9ÿcãp\«qœeëĽaB0t»†Ô=@7Mâ†äcœ‘¬Ù’$s3ÈG{†ûŠÄfÃ×Y ‚ þtå{À¬àÃ+¬w%fH7ž0æÔE +¥HJ¶;Œ“- 6Lü¤µtÁØí•”Æïé¿ßÃVÔøï ô¥eÀôw~Mê}”c¹â+µIó#þtû[{:M' „©¶9¤'—°½¨T6‹­düº<_óÚC·8Û}@ï^>€)¿"½R›-¿5XŸŽ"ðíʼnšW<ø,­O7KÔ+¦) ±Ü…› b›;]l¾j-Ö•ÚeNŸÆNÖÕûÖB {[®ö{f µíˆîþgû×%´DŒ‹W+2ö™ÌßÈД• ÂÑ@%šF<+‹")âÂÕ,òð`5„<%0IÎ=Àj´{‚9!ÓÍ‘ÖI5¤©jÀq Ò<Üqo™u9¢;~¢4¶3ã!¦OArtQ$’ !))Rq­þ%8z¸+åçø}>üàxGG4}¦9ü¬þNÑÉënfi‹Ç¡›ï Ù£s?ûždb‹ó«Z×Í·| øæ¢o^3õµøš¶³ŸÂoõéÂ[+ÈÀŠÛK}E™I3'*J]bFTQܨƒkå¯D@<‹‚Ø“<寯-÷ .j¬ ízêãô·ý×àeL¸Áþt @ß·_T£Av‰L'"Í“ßòša0 ýŽt5FyN¹˜ãºMÍïµ—(ÌY>cêÛs„fäÃγá$?ÍÇäW‹¡ôæIi@­W䬌§8‡”ÓþDÛŒÆçZ^±Ü­&¦-»dEµ´Þ:òÎT²É@a]ƒ‘AÇ'gãòm”äÄñ8’ÈPbö©Æ%m¼UØ)¨/¤×¥ 4OÑt<¨ýDâýyà¸ÓÁ.¡†â9ôjÉGˆö†ÈÀ~íð?É(ŸgCd?xɈÌ­i›tŒàÕö":$ñŸƒ$׳ ÃyŠ;RŽË`çOòIï¬i‡j¤†cJå¼z4b׸¯Z3®OÞ]÷76Í|0fãÀøßFe¬®Wý¹ûº]"šëïÅd¯âÛµ9aNLzââ‹Ã§H €Â4àɽÍx³êD‰hcƒw#óOG†"ºµÕB[|„šú}ë±?ù=€¨¨LpƒV‹ „<‘Å}0ñ'à’T‡[s:œ¹Ú‚£•ãl\Ô¬vK¤Á`))¯E£ ‡Ð@ÖÑYt£8ŠÝD³6¬Mg 7DÀƒÅpVÑ$•§oƱ®Ï%ȇ‚lÜÌ*BEn SaÑO‡ÂâV¡WÅÈ é„ìíjà%ÉÁïÏxùKzø2=8Ü;üõ }òòé¾“ð‚‰°õ™«XðCø=îµ¼-voè…’õ÷ÔÌlÐbˆÌAíîÀÿX¼NÏ×B# -NÈg¨ÿe±XJ¼ÖóO®Q; Ÿb€ëµ–dË"]ÞŠmmlÔ »hP`.­äi½`Ó^1|Ák8 ™Ù]8fVF}úšaç,ñÔ/»t…Wéɡû/ÓÃß_í£¯W­W{wÍo¦»È,Å¢œ1jÖÜpèé.éOªòŒ½(­ Ü%1¢a×â¶šÊ dGì¢RCBUmnÝÃT)e£Ñ»¼EØN \£g€¼Y˜n@Ý.®I¬É¸ Š· îfÂ$¢ÂÀÄ—p†PDÅ;È8aqÔ|6 "m‘OAñ*о«‚Þ†\í·­ç·…ô‚Ãs_…#}t;¿v¾·D¨ñ»¹hÁcl(àÆ/Ëÿ€|S R£ásA&z¨6WÑ0÷Ûe`-TwÅ›œé—ø6PÕû6ðPP¥A~€)¥('[3ŽãÖbßëÓ÷`*T±%$7¿ üž“W“”UÄå›÷TMyá™Òäã PZˆ?áß°pØNŽK±ò8¼ºzî ëªnZÎn¸eïE1xb§ GÉ»>š¹ºæ§s£†~­(5 ëQr „ÔÔŠZbFnÆOgSž˜y{?nSR:2Ô1ÔíÊg'F€—×/ùðtB‘T‡ãlXˆeÙŠkíƂH ²á›¨™—Š>‰½Ea¸UKçÉ¥Œ»U%Vº’œœ¼( öˆFªŠÞÙtø¦Zâ¼PeïÄÐã93ÜŸVÞêNϺqGæ‰úñ-F[TÉ=Nê Y ľǃòøÞý×ÖÝ?É6ï÷ÿú°×ð׭͇÷7Nz½Çýí¬×û¯~¾}ÜïÝ¿ÞX?qGù$;Õ½Ç ‹¦Rø°wP£mñ“²·§jÊ=Ézgù]hr\ ÉÊ°¼Ûƒg Xë7ŨŠö³S™@´_MJ•ÒºÚkÓø°'†‚NQ»ÖüSuž½ÁXTøð”—£CáÊ?¾ŒÌ~27´}›s• O!Åž8:2 VÙkY{w”€Î숵œRÄF³nÖÇ|·b%N „ÅϦ“’õPË;’±’8±B@/Äzœ›ÚèL'M²ò3¹ƒ§ð;±$˜ÈI×G”²<«pºýRÓÁì Æ«„lðåÚ¤ØZȶ©M×2«5Ü/ȬÃp«`îÒö :¯ÜW•ãjÑï´JçzJ@¡Ê!Àâ# aNTu fýób˜X^³1>Û ’Ny #qC¯´Þž‹Ó;£ý>Ú„Eð@ˆêâDNdV…[h"Z3¬pmy]¡¹ÊhD0H[ WÁG˜YÞá(ÚÔ[ƒ ÂÚ5¬CT{êîêlB¶vƒ V6¦bW€Y³Ió3àc×ÒÔ¬q´ &L0Kå¼ö‡T¢–Jw´6Ód…åì&`dM³ù ˆÛkب¥µ™F´ú©½ç5ùÞ}uEYâÊI}H×X“j4`·8f™-ÅvY—'3×&æ‚»è2h±Ú5:×ö8€N‚Újý½Ý)ùE_Éœ”Ç`#ìÇ·¥MØ)Ot‹w› –mÍš=Ž•g];]ócàbÙ%gÜR‚%“ÚJ?&+®âk!‚ˆh ·e*•´"|Û# Ý$_F?tاk&$‡oMúéõÞ«ýôõË_Ÿ½ø)Ý{ýÓA·CY¯S˜yд7=(ÚH ‹Óà{ƒ(%"HyôØFc;1‰ËgPôŠÉàRgã• xÍ\”8>\oú¿C7BSrט“>þ`¬#Ì‘6á!$#t(J“ʸq{âÓ–:ÄC[Fˆœw^âÉnÅÏf¯ÈlK=j å:(71ú /šäI¨Ñù´Ê}_8£¢Tš›#ÃÇü>CT®Ÿˆ ÊÜC‹‘ýš;Ã¥þ0ƒú»äH e×JðiMvœ>$Vg¹6rTwû9xQËtÏ<µëohŒ#¼ô”ðHì§Ð´3¨ˆš€!‹e…zã ²5WEüfö%¶Ø…c÷SŸ~Iì 8‘ç\žN¬º9éXï~#2*Avlæ‡@$<¯:ª¼ÊÉ ¸jqù[˜ÍÄõÕQíwëãé½Î¬AS‡ ˜M¦ -ýé¬"2"D—Wßœ¦ìõW“¨¹jì‹í ˇ“Äï:Up8¼Y3&Š`OžžžÙøV\Ô:DþÙ½>‡”Ÿ瘸ï=Ü üË𥷙r¬‹Lb½Ç‚c¬óh°W0VƒWD‡ºåÛ_¹µ‚EXýˆÿ pæM#@ÎËÿ#þÏÿÞÞZá?|9øžê"™†9wÆQB›*l{gÓ»‚èéG¼A‹LÖ[ô^—¯Û6’;J¢ßŸB€'Q³M ]TMú‚U÷8TêÌæP¡:?·E¸"èy“_û† <+„’Ayœ ´ 9hsÁZy¸ru-JÔ[Tÿšo«µ‚ÂYý³ý?W9Lnò˜›ÿmÛËÿñ`c…ÿû5áxÉo>g~‰½ÑH¸YÔßRȳzK­?¤ÕÅR¦¿Ãº|+•T÷±‡—*3A¶&îj&>‡ KbRÅpèª[Œ1_–Ó†¸‹7¹0ئɓ‘øª¼évÓŽP5 úÎÆpmujjt’ß}Ç 3P‚¡Ñº}P£ks6¼–þwc 1õÀZß ?«Z9Ú Òw„­€Ÿºo;ocMxA~…ö2ž»ûw©É0¯¯úŠµé¿:û|ôóÑ#?ÿÓƒ+úÿUÐÿuû©Œ`jÀbÉ!B…<çÓ˜E¯ÐhyˆGmq%%Óš>Û&ÔºI@×È4TQ,”+HH*;·ÅK™ÌnÞY¯TËËÜYëÑ3¾µÆù´¢pŠ¼cT09“0-ÒÇïŒ&Ï®-n]Ô\Kl#o}1l•¹9„ŸT‹ž´îÁ¨¨™HÁ(it(()¾!X´’ˆ]¡g—ÏÇé"u\€êz@ni$ú)ŸúéÛNåÏœ!Œ ×÷*Å2ÑO ™'ªëæ§ óð£ÛŠÅ¼õ#^ƒnkNg¶i nùoq·,e#øúq N‰©Q¶ JH0ßc#ž¹Þo¶óßšŠnjÀ{¸1äK˜€ÖˆBûéíW¼ ×ßC¡+d´ÐÄrëv-”µDñM!XS…Œ~c¤µ£Xë´"ú”héß.ÃŒkÅE ‹(QS4“±'ˆAÀ\³¨‡çE€¥¼`…¾0:š¿Ð=4&”KÏBPO‚ÕϤLÒ[ŠUPnQ3â B pi¡QÈQœs°‹bd^±™`¬5û¿QdªìAÆÄ™’ûKÙ(]ê«íy4ë„à/ £>˜””‘,'G<½&xÙ¹Éä*ƒdöÕ’£ Ï{¦”F>Ñ$9„¬Wl™åµ7דj(®“/LXkÓU)Žž4Âì+fš8Fÿ+ó “V Lè@Œw‚-DG  ^‰`ƒÖ¥Z~ïòú•¹£†‡½X±?~ŠûAï°6ÑT«=êcÁ†X"ê×­•AY£Î:Rçv´D¿«€JIê)HŒNµá\ÙW ¼œð$S*!±7Ž°ÃªîQí ¥o8â˜ÎuÔ ØZ}–Åôµ!ŠŠ0º#ó ZR¸¨c¡×–°è‰&1\[ “™15ðá½P©È'[WÞjXš`Ž‹~xàõ U¿6&Ñ0§ŒØŽK¬ÿ·ˆÅ> mªíø¤,k{‘”[.ô÷WQÿ1ô– ¯ñê,ç^3ê,JŸÚÁ¼<å¥øß¿å:<Í&yíð^äÕÄ âÄÈÜS°`è5‚ð((3\1 ÎÄÌÉ—Ó‘¹Ãhdß|S‡‰‹R¹dQð–$¶ö9!äüíO‹Ϙ§ g×9±®¡_‡J~ 4ÆÞϵBZŒÚuÀú,Ãücôž"7r~žŠ+†ÿ›qXˆQ‘¡%ìé‰÷”ë±mk$:ßJTJ»1¹"Æ9ŸN¡)EÖ±#àâ‡.k©Õ£:²ä«£ŸòÀðþ˜¼6ÑU+ì¶N\Š`xz`-bŸæù TC8üš$‚{IE/iy2îvùO3sÁ³ rÐà|Ú©g“»YxîN…O3yd”ó¥E/Œ‰˜(O™Ü½a…2#'åRó Òrœž¾UþfgÿTj—TR-;X£†É®ˆaŸÆ ²À~>[î”þL»XTÐä‘Y ’ sk F80R'ȯ"H-ø9UjLÇpΊ*ß;˜Žã•þ É[G¨ê¡0 BVBÌZI;ý×O¼ª‡Ošd"¤ÁŒ¶®^-×ÀÌ€T±ÃÏ ]¦ö¤Ð *·Âˆ¡»ô2ÃÓ@lÎ1øšáEâ; AŽÜFtL5B(Îé°)1P/‚ r—ׂp_—¹ls“É° N5ÐUÙ[Èí"€y'—ÿcfyìÌb’[©ýgÉ µ ¬‚ÓRMaËcêæ²2ÝÞ"+ÎCÅ‚Nuj8t¸ÝIHYÙcÐXnÛø ¸¾Žl¸KF³èÊóq;eÙ‡Ûà,l UÕ.VŸe›üPlÿ‰{$¿oÆ dŽÿÇxgû ìgF’’é#î†j•aP]T®u£e`Êét»¸·þ0 ¶„üÔ›æJß‘«;š´eOÈÈ Ø PˆPc’*ø_…™ ª,‚¾¢\?o³K?¾¡”¾q„¾cñì­¯iˆˆÁwæG¥h¥Òäþ†„8œí*4:i™¡¥84£™…ò­‚ÕN,Á Ìúf;ÍoÕäRöÈ«C:_ÇŒM”—Ý‘¼ºÑžòŒ‘OðÃªÜ j€Ù8ÚXÈ•\ô~¡ ÅàÉ®¾D—•¯wÿ]Þ›¢Ž‘~‹öÈúobÈÃí‘H®ÇKÇU“G75³p}Eëâ’cA;@M+ù,ÒÏŠ¡Ù²R7,Ú8Ùjz¬>(æ¸9ã18KÉ©"‰ô ¼—½.¯ÛØXRH,9{EÉÇÖùÆŠœK[GŸÈ¦]Ö6­ Ü’ˆhàxË×6 Ù¾Ÿåð‚mTŽ<=U¡×¬kçøôáOlœ·Z?q?ñ"Fßú¸œœ1¸tÅöy³kÌ,rkÔú‰Ë Š4´ÙôÑØôr+Å+œÔ…XDþš¢x›ó•Í­„d åŠ<̶ï,Ί‹° éØ ¤¹âÓ¼3ã£ÚIèty'±écæÔ@ôjPå)˜‘Ò¹-Ø»-È(Yo£ûP?kmÅß"x¢V±]u—d:y Ê3€Þ4ƒ¨<)ÉA¯a°&øL'„q!„¯ÌïÁŸàñÒËÌ—1FꙣŠmÍÁ‚hOtNË(ÕÍ0ªŠsˆ•ÀèˆÇs¤ýƱéÙŒƒÍ/Á¨ù#„e›!*Éñ•°)kY‚v;7A¥ðnÕ„°äà/»yô–Eß™©Ûg°/JéNø©èGj#”ž–ÓªáÔj ¼šyŒ"€ñ;D­L ¦Ôé>x›˜^Zã¶-'#æä^BFB.ÇÑKpÃïߛߎü0~£¥ãé1.1~Ø/âþM!GMØ®à3Ëp¤ú;Â=5;6W ŸKh6•òìØÀ{ÒFãì›l‹nˆC=\·I½8½N7±DO2Æ”¡ë4pÏ(—Å?ÄHˆ‹ú±+Hӧɟ«‘Ÿðïa€×* )¬m-µí¦[u™µÉ6g«‚¥—YÞTÍíNÙG JY«?à&ÍÒâ ?cñUžø\Ng_[…acÁôV_Ƈ‡!|•Yo¶Chž˜§3•sŽ¶ôH§}û‹wìåˆÐ @ͱÿmoonºøO¶·Vö¿¯ÉþGç#ó{/möCœ©1á¬'*ü<˜µ ªÿ†fžÁ9J(‰·Ê ?Íz—2Ø/0AÏ/çð?•¼q±Õ˜Çé@B«¯óÒ©$Q£ŸM²ÆÕ‚ »óÍ`Ãsú=Ó ÔõíóP‹rUF&ÇùÒo6¼´¥ÖÅ…Ñùù¨§”…:ÔNVÝ9·ßÄÔÊ1]øÒ ZÝoäx æ g—ý-ûª¼ÀœNó²ÀˆÕŸÔÜ*8K¬8˜C§u#¯gȲÜ+A¡·–¬œ¼tì¶`›šþw÷¥ø ˆyá/=øú19Ò¤ún¨¬‘¼‘~j¹Æ;B¤rÓDðó__ÿ\ûIñe”þ€·¤‘mÄrM.¾¨¾ºI©N››¨pŸH€=r}„}%¨l”œ€ô駖 déSÞž¯¦c'Æ°Üã²MÉ{Yîâ F})viÉP*~òžAÜ0/{eÈ}Ñ01†(̼S¾«M¯Ö [õÓ½H ³üçý½§Ò¥'éYÔo;pܶk”©h%%œq ·°a¸u\ETx¤¶Kã~ù ² ÌS€Ò.2,u¼fŒ £ DÿmAz‚UòÏïý]%}§Ç6±Jóî7夀ÏF£6æH²1œÅaàE@»Ö³“O=º,Ú±‡¨Òò°RLÓ¤ÌÚÀe[/Ø:A6Ç×Mº¯œÌ¢ßI9JÑ$; Áƒ@š9Ùªé_k&yô²Áª˜ŽGæ­E ,ÔUï,žæ·œ7¡§žÆP1‚`¦¬9ø |bjØv?ò›‚'Œ‡ûÖ(Á·ýá'ð/÷¹ áo³q?§¬'ªÞZds´Pdëù¢D‰ãƒ3>ߎº¥WžŶ2Ù¶c²Å’¾ËºtBbÏ£&Cý-w£—F˜>÷౟a‚:Qj-LØ€(±‚PÁÒ±*Œlk„ Hx)n öǧÒæP(÷beëÞøË{ B~³j¹[qX³Å…§L]íVZ\ZÀšMÜw‚®åâJl´‚"¾|ùÛr<èÏ œß*éESávÑŠíDAK»íÈ"Öh' Ýò¼™×BÇHv³>GÎ µÓíÇÖ˜’¨ùÞ;—àÌóc£ Á?W­¸Ÿç#– ¨;·kÀfH@~¿´\zo4~eYò·©\:ÃuÉ$TÁÛÂ]îYŸI Õ_ªÊTèêþ!ÊcÁ’dƒj·iViÙæ)Ú0¡Ij„àÜ S ¿¼m‚¤9*—7¼#p'ç)•‹6êØÒÑ/°iÌ[˜à2ÖþƒÅ,Ùñõ…Dytò'Dy„ãàïB<7œ˜ÏN;šýUê)3CÏD·Õƽ-ñ”ˆ1ÏÑ"ÖírÜ/(Ï7ª9HE¡s² D©h„ #ôVðñð0Æ£Ed*ï¶$mÓœ4éÅmº)à€MO‚ANEï0ûÂÛL"Á§ZêÃ;“§€f¸¹‘E­OÓíœC­Šã8×(8Öx† •pòѲ¼'ª.©ôúªÆդѱ2¤ŠûŽÊ‹ÍW+ÛÏ—ìÅƹ(Êi¥Ë¤&îÏNô8øÂiåq]ífÍŸ.Äx%uEt-s…”röæ •ÄØõ/ $PYyœäõ*ˆÐ“ÚEšý f©\E‡õ¿JˆdK©5fϸµ ‘©FjÊiº±pÑj²’™%Mk» ¬QÂØçmLƒÇL/ÁD| ^©SÈ(>//ñKE({ÂûÞÜ ]Ãx5¿I¬‚­ÀÐv¬¢ž_M4ðrÑ©ÆòJÅ(žÄ‡Èü¥ôêà¯éU03"1U„’Ìœ•û0Bw'>-7ÉyVÑ·éLãF\‰þ¬-ùŠu8: óM U½#º¡°f¥ÂònHÍD⤂§ÎÉw/= ÆþÁl´ƒ¾X X±Y…ˆ’(£ w…\Bæ:¶©ÔG,gqBM¸ði\¥#:éÖ¡‘™eÀcÀp-:ØÒkï-&á éÕ0ñœTez…\ó´®.ÄN¬d®çrWû;õ»×=b «³P/<9«–›1zÉùayÓ£ŽCÓhyÓôáÍRwyIúª›Å&j¨[nn²ÁÁx¶»þ¸I›6ì%'nÖý4‹à ®~!¼¡,¨‚m¥BB aw"vÁÚ’Vi•Çuw¦Òy-û‰TÍÙ¨¦;àºGA °X·¦ÒG{0+þàx ßìzÍ“Óù#}n¾¿j«ÁwšÍ§ƒÉþ¯¡½Õ¤›*ÌY\ó@šß`ÆN´§~ïž Î°¾ERõnò0ãMßî:Èü–ã7ÈûEÌ„ž…ì1#€èC–QÔ[3€˜÷Ó¨‚¬-'˜Šª2z›3™NÀVÈ*ÑþE>æx (ò“«2*àYÆiÚ†ÕÛýØe¥uýmÅŒâº3žÌæ¦? /ê(¸çÑÝà,¯>JG‚e„øU9&ÐP+ÌÚž¯©c÷ ¦5óÑM ä̱tê5V…T· ®öy†ïÎe!Cdz7i×æË2™s¡ñº¥¬!SX-yíQø¦êRšIf¯= ô‰Á¿1àùÕÑâ’®³ñZæ<\«Yó7G»m Ê tT|)Bz¬ÍŠX³|#¹ÓòŸ `´õÆànP8'ÿëÖÖÖCWÿ·½Âûªâ?~óÐW?'öÛ l•e¥3ág­:AË]Ðs%ªgq Ž…Ô¹X%£vN…šÆ û1¡–{%³ÈËQ>¬Ø«œ5‚V"Fuh‹˜ÌDd&´¦LØ`y׸Èú®äWg“l ÔBõ­jKªÌ´s,FäÏLIw4Œ{SæWÙ^Çúªö¾€r( =am{ !Gh­ú,{ZÝo:ÉÉt0À-ÔE›aûtüÚf׈Y0 9ÏG†“£¶Æ˪5±t•þK±ÿ©C|³ÁŸsïÿ-ñjÃÿ¼¿²ÿ}žœÛk¤ *(ÓÑ=c\¾»d»—J —íXE}2B71è9±ù¤mÈiÙÞ–cp/¯Àsu}¯Ž@®/ ºšdÂ0r•æ¬U m"׿±dW*t$D|À*§RUÊÈ<“µ:fòυ <Ãn0ð‚ˆ¢cãŒI‰ò2îœðÔ †äÎ!³‚+ßÝk<ë»ïL-ÅW‰Š¢Á DZó¥eÂûQ¾lÅ3s Ó‘Ëë`t”x3E''Æ…˜¼dƒ*÷;yl”wý,ó‘[à&Ö v´Ú•ÉëgyÔ±ªÍ¬WwcÙU­žÄøÕ»ók<¦æ‚)?ë5kÕ ¦¶°tä®ýôF-ÍG,ßhñ3†ƒe4‹ëûÆŒK‰0}Ü\S’ï®Ó•ÉÐÁaôëðòù>çDyà’°,#AcDe(Dh'ˆ¿‘:Ï·jÍŠªÐ€WÙ”šwÜòwÙXLˆ 2í}ù;*ŠQÁë©æîüRŠâÿ==!ØÙÔÖ13àØ'][Ý`‡;âéI>†Ô_:bqÝÌD)3@R“*$×&܈J£g :‘X:E4!›©üúw0(`e8¥ ·?˧ÅK8̱2íHºêQ}xÕȼ€ in¶¸©â’uáë©aª•c¬!L3„^€Ùh䥘xQ)'v2²ó1&XìÚ4$…*¤Xf S^FM‰, ~Ç‹WðÐ@ÔL‘¢Þ殿7+Šæás^9³$œ/›êdÍΆFn×K/:böÊpk;îtÍZ-CÛ:XÄÀ‹){HST<ŠlÚ¤0Žüÿ¢œ'ŒžZ!âÊ·v³¡ZC–‘qŒLi£mxâ{ýx‰4ÐöÓ/[dldM»†`†ŒâßyÓÔ5ÏöµŒéÌ䉰Y[ˆæ¢ÖÈ|V[Úo9çt¨Ü •-8LU&è–›T¬–õœRÊ›<ؤ¡ ¨iÎ(ÑR\ بÓUß"Zk×@{ÝÞØt2·¢šÉcÏØ}ÓId¸-IûöãVMiÁÐ@„³éæ‹/btsÙõ;¡-è†_øYákJ‰ ‹ ²_¦ú(¤¨Á߉ž‹:ïЧk- R‘?&vÙ›||Ì-âf'þg©+À:³u'Ë0ÏÍõЀhÓ ¢\©Ö¬¾ý[³ã.¾Š® GuÌ èPõÃ%u7^râÜ`óM±ƒtUg©ü^>‰¡å5ã&ÌÀ íM¸kÄ?ôJ!¾õ&E[2·Qþf†óýÀŠ9Ap@T‘578Çò6ðƒ.쯈k(V‹)Ѐ@ûî T<¥Û„6>šòD8|„MͻU†[ ùƒXb™¾‡·˜-5ÝZ.¡àC ‚˜Á§åçÉd$þM"l’ü´¸ˆÍø{§bÔ"µJFÌ -û¶þ“chœÈ¬qX&Œ™ž:ñZdu ø¿xä©Ç@Çž³Ê_:á'ôu6 †{ÇBƇ?nüo›UѺKbšÈ Õ–ñMòª¢÷zàÒ°’¸c¥]è F¡MP'T’*Ô"Û vP4é™›Õôä¤xGqß1ý0VB~œú¯‚õ|!rïÞ ëe”DÇ_N;,5ãg²c½3 íËÓ ð1ãÌ î×je½h[$uºV ŽWpT­š~Ä9éOÅÝ^B¨ T^³@›ENë¡Þ^yi4ÔjÍÚ¼ nÎ÷¾E݈ë×ñɳ“¨v%òÓšª„#Kf}ì¶!ßä¸Cç#'BÐ8Ø‚šMŸ€‹;À:@1~i{~]I½kEL¸ãµü»Ï„í;$jÖsym\Õ6^Þ5kõ­Ô!L-fDÖ\/7 Å7ȇ§@gv¢ »eãͦ`*äSŒÎ'sS™CrX1Ÿ IHfø¿î‹an)Nf ô¦È©Û,ßÉ¢š¯4—ã·H~ÙËĤxÑÕ¬ÏâÑeø;5|C» î/ÀÏyè±Q°¹`=£˜’-^!¦6‰^Þ¹ÖËé |°šmuÆŠÐ 9tGÜ‘ŒY:BMÂ-]Ökæ–ÙŽø³£À=.ì%ÝñôÕËg/»,í¬©Þ‹Xè ù¡¬©Î :Ï !Á±'>æÚSl3ý:Œ³y%Äφ*D×ʆdÇÑob5a—V[ZŒ]§:¸èÄ~ecY¬KV ¬±„)Q*«¦b|ÄêÅ2’z˜µy©ôŒN×£q9AH_C@™J2x M×tPs‘ƒøÜ ñº°t\@Ò”ÊAŠ!î×`f9y;0LÆF”Ù.0¯ªLðî8ŽpV~¤{ì•å›"v"ë7e1C5hÈï®ý‚2}/OÁb€~:T î0úkV)[Ë”xíºü¼Õ­zrá$D£ÛÅÍŽ–ƒ¼Cv™Ãì!¸Ï,ß>ÌnÂ>Ú°²¤èØå?è€Sˆub»‚»ªž¼oñâàšô©ZvÀýPöŽåüœ2y£žyO†H“Ê°øÎ8ó7íZ­º/&´)19ÝÅ ¿;(Þä #Ϙ¨;B˜tŽa>¸E´ˆÚ‘Ú7šA»®d<žƒ>Ñy.v ƒø™$?À;Ê…-Wå8ž bG¯A"µóz^ôûƒ\pE2›\;Ó,™“ÕЮc%ÃJ–˳e·$ÙfZ³d)-¥¦¥²•$óšÔŒÂÉΖ,›âÎnÕÍõ6w¡Ü á*¼°9­ÙŘ&Ø¢Ì`²h“²|°ÍÚü(s[¯­ìÇO4Sû¹ü¢Š¬Ô¨Õ‘Q*G­ÁÑBä9h ,P ©ö=‡ŒEÀ&œ×§9’”kóÛs¥”S> äG/Næ 'º‡:2ð•´!›‹!·$´‡ä(‘&’¹rÓ2BWÃ…ÎÀÌ‘·}4©E%â5ÿÔ®«ÊÓùñ$ÖN©œ,–yw+d:þTäz bVKÆ8që"°†P®¥W]ðÑÝï‘¢åLaË^骂 ü@Ý}{–F:ƒÿ 'l&üÚÖz½÷j?}ýò×Ãg/~J÷^ÿtÐuqåÖ±RCee§mtÉÑDR€mYN vï NŒõ†­•½Þtldк_«u¨ ¢ Uƒ%Cl: B\ær6YøÒQt6™ŒRÈïUÖ40?é½Q OÊnlÔ6µN¤’›ûøN4¬ËŘ‘”ê™íuØTÏ;ê\  yæ×fà Hèºö–cíVŽë-1yŽÎŽk³0ÆkXÎTô ­éámlœ9+ùüùqÞ§Œ[Ò6]yï;R‰Ü­9¿í¿>xöòE·n^òý‚'[ˆ)*gsàÑ Z±ÇGÎ>Áª…ÿü õúû˜âÏrÿonÝßöîÿ‡«øï/òþQÈÖi!GÀBb á\¥Î%ibtîFP‘ÿ““»RÁ.½£”G³d=,ä Abš"¾iØ•O'QCA$õ “´ª_2ÄÆ1Ó¨]d,U%Ñmµj=ÝŸ‹Š,©`LÎGMji™üìÖŠð<26Û4K/ŒZ°Ù\Vä±h¨ê÷Ä$$²¬}O¬`@¾ú?ywSP sèÿÆ£G®þïÑöƒû+úÿ%Ò­Lùläßãúi3tS¨X´ë’[I/£$@Õ>Ëåqg'ºýÇøat»æ­nCñ¸pý…bá.B`ëÏÿ»óÁç9ÿ›ÛÞùßXéÿ¿Èó¯uÖ_áù—-%6šþ3)_>çÈU-¤LÅ¡…‰ò[zÐǬ$"­?;ý¶Z±b+þOÒ%Ü êúÿàá#—þ?|(^¯èÿŸGÿÕ^0¬»@é£ï¢ƒI6ìgã>ÞL3~Ø;ØOŸïìý´þ}ÿwAܸ­böQb*[5â“qžÿ;7+î¾~öï‡5UuX¨Sùǽ_~ùaïÉßÓ_^>ÙûeÜr;‹’Ä^“Á‰º9'¨ÅAyp4Ǭù˜áÜÀn¯ÓVùX_WTŽûu¤ äßNAÇÛé6‹a?gæÀ|Vâ™_à XÂp—O_&®kX “K®n„ñ”^ê$ôqô‚C3ú„¼M‰Ô#µ°0Tgåx¢Ôµ=1®–nž0\Ïs1\@Ð0@4ˆ™òó¨UÓóól|‰€J`t05òª"ïQžJŒÝ$5 bÿëMåZ¯­¡ï蕪«oñ™µ‰ûÀ)˜Ðqrè;rõ-®ãéíȉÎ,­€Ø þ1«N§ÓxEãh´Õàºí¨Ó8 á1÷_«fáî¤Û•ñåF‹ÑxSôóIV RÌÊø!¤N¦ñöÃõ÷fÉÎF÷*òNä<Þì^Ý–0ç…›)£FcUìg}ÀùX~s¿ ¿}n¯¿¥¯b®z›±ÈBÕÎæn€úθê-²yêûÓµ—èR7§‹BçU§ ¼ÃiØl⇹µTc0¦©¹Ši¨:¹h8È;AÀ K'Ë°8í¨±øDhÃÓø4C­“EÇÂ#BŸ¨¤ÎoƸÉ,>lA/ZvWôct$š±ÑÛœSkµö¬êÑΘ¹&üIòló¯Ã8\Ë«³lºk‰™3Û`¹o0“Bès¸™Vë³ÈcAþ¿™M 0—ÒhSL–s½¬óô¿mÚüÿÖý­G+ýÏgù<@ze_°pI4œÜýëÚÁ3cŸXÚo¸K„”àø ¬5í§MN¿´)Ã?Ør`p›JQãòqIý6•nJÕ]âv›¸ý'r­ÿ ‘šó¾9s=š¤$˜\_!0÷üo>pÎÿÖæý•ýçk8ÿ¸Oöp›¶ÛÌ£¯äu—9êÙö”¸-!rLüƒ‡^0SÕZé8—9ÿ7 2ïüßwõâø?Zéÿ¾šó¯ E3ÿJ(¤A»^úð«íØŽ°±$rÛLŒæWgý£Ï?Ð[>‚Ì?ÿ÷Ýûãþæêü-çÿ9mšE`]ûð›{±M%æ‹ØX‘€;ÿä#€ùüÿC÷ü߸âÿ¿šóÏÀ8ŸE°·äJøç?³våš`îý¿½ížÿGVþÿ_ÛùÏǤœI j|’Ÿ^^ûä«ÍÚJÔ_+¦ÿFÏ?âJ±bÂU¬Õr„`îù¿ÿÈ9ÿè´:ÿ_Éùÿ‡Ø&tô,ǯå™E–>üµ;quâ?Áù÷qp?J8ÿü{ú¿í­Uüÿ—þ)‹ã‹r²G»dæÍ?åo<ØØŽD[7Ö09ùí'ÿ9Ï?å¿JOÇåt„–ŸöüoúçÿÑ£ÕùÿòÏ?í“Ÿ`›Š]‚.Á7rïû;puÑþó9$?úøÏ?ÿ\ùóÁÆêþÿjÎÿs±Màøϼþ!K鲺o¶#ÝLbü½"Ÿäü”Öo‰ó¿åúÿl<Ú\Ýÿ_Íù_@íG;iù“/U}ô_é«·:îŸçü_ˆÕ,ÇMæóÿ®ÿïÖÖJÿ÷õœÿßp›Ì§KŸ~kÿ­ýg;ÿÓá›aùV%ùX`¾þÏ=ÿ››[+ÿÿ/ÿüÿJûä%GÒÌg–0ø;{PEͨ´¥+zðÉÏ?æÌ?½ÿïÖ#OþßZÝÿ_Íù%·ÉL €›iùó¯ö 'úNè?«ÓÿοN{óiÏÿÃ-ÿü¯ü¾šóÿ›Ü&3Ï¿ÚL©™gqB ê·#»©Äù½" þ+ÊÙ”÷oÂ8ÿþwí[Û+ýßWqþÕ>ù6Àð.\îOþuf¬A[ÿ{ þZÿÏñd(Æ9Cn¹ pµeÈ‘çð»PDƒ$ :óV• ‰•„Þy'ãca°.H…5^Q¶ûLÌUŠICA%€›Úuz€&ª&q¹è§ÎHàÀz… ¢ì"-@†2úsÑ…ú˜%ëÑ8?/!UÆ`€™4¦Ãa«pPÕdzrŒË󺕎0G;¹P©$KâŽ!ÐJ¯^äcH‹'3rФ4“scAâwÂù2>@V¥ð®ùm S3Ðl4¬¤ ÀbNþ¯É°ðUÓ™bôSÊ‚Ùóå¿íýÿzéÿ>'³s ÈÔÍûÃéyndtÐi.Ô¨ÿ馈$Ó›®—üWmuBŒÛé¸eb¾0]¡•Vhnï¾ór=à £ÛN¦ƒ¼]*Ì w5|dmDÉ09†5ÐÓ9‡gé(+Ƹ8 ½Lf 6WǨ…½å‹¢Ë"ô#·•…’A.0¸ŸZ¢‹J ¸vtaá½›C]|„$zÓáB:dh¨ù )[‰W €‹•õƒä Ä\¦&Ë¢ù…õ-)&öÞø2wó«|Ó{ߊ®âé°øŸ$¨•FÄí:Д a™5…±ZÉ«!ÿŒréí/ïuWÑ_Þs·W ³¸.’ǽr:œ@¾­Íh7ˆ±g”E0S»‚ P„mi<¡‰Ç.ŸöŸ(yêûÿSdþ]Lþ{àúmno¯ü??Ï?áëý¦SÿŠÆ–Mýk%ð]"wõÙ„JF!®Éû»XÊßO“í—–sÑl¿_Sžß»ß7Ëãµ£2;ˆ›Oü0nßUöÞÏAÿo0óß‚úÿm—þ?|°½²ÿ}1ôßOý7'Ñ‹8µyo§ØJZ(ð½–ì0(Çø‰›Í^·êÓåQ­Öê\ßðù÷îÉ$óô?›žþgóÁJÿó¥—3ºAZ`ÐÊØt€Úæ@y‡È­šKb€ºvsïzdâ³Ð¡Ùi;ç 04ïTbºNkÕö &š¾ÅÏYPŠ‚fk‘ßZt³:n·y’ îÉoÞNjÍÒœT˜Ppm£°3\cV!Áæ¹[çf!4 Rùßcö¸üTªg¶†ÒèÁVùZ-¬Ûy¦'½ævÛv¶0Q~VÂVêu•¤uuÿßpæ×ùÿoóáý•ÿïwÿëԯ׼òknW±Ý g¡¾Åƒ(1~¯²~Þós™_;ÿ¾þ÷áýþï—vþµó¦Ä±ÑfpÝËÔ¨.={² Bó·<„¸Gøà ÑTc¥'˜}þÏ&“Ñ=¶߬ hžýg{ó¾{þ7Vñ¿æùÿYìóèÿÌÉ2¥ì•*¹wï´˜œMã^y~oœõÞпŽåñ½ó¬‚«¶<Š+ÿ|xø*ýmÿõÁ³—/à÷NÔ09)>_íþœ>{ñãK>º¢´zä}½ÿÿýºp˜>ß?üùåS,j?rÊ‹W¯O_?{ñ7m>rJ?yùâpÿÅazøû«}.ý¤Nòáä.x=«Ò\ü§ýC9^ñ§;©—‡r2âO÷í¯ªªøÓ_'?«uxò³óúéþ/û‡ûøšþtÞÿ¼¿÷T.ºøÓyûòÕ¡øð–ÿt§…_jïÉ“ýW‡¡oh¿qZÿgúdïàÉÞÓ}[uÿy÷IVõÄsG m¾Þ{qðãþëtÿÅ“—Oá[ÉÞ¼7¡ê4$§Cã;Ã_¾~¾w¹ÿˆJÒ»Áèã?àÚÐôŸòÐݡñåùàsÚÿ<ÜØôìÿ÷WñߟåŸ|˜ˆ-Œ; YÓU  µtk†çΚãF¥-¾e>†tö¢ŠȵaèE¿U¾f÷lýzœŸæïF5u1É+½ËÏG“Ký†Ò¿‰Wý2¯¢a9¡lÁìÚL¯ué ÎDb𜜣U´ÇE£„ʲIî²r\ü›BTÜ_Þ-Òk ,föy7Þ0 ¾Iî'¦[­Ài *GO¦ã±x?¸´*—C!U%`ÚHq ŽÚòg¿8ìé (þ>¶ãÛ°×&öµA ö­%(Áñ ì½±©€ âPÁ!-C!ŠT£LP’bx–‹ ˆ¸ÍÚWÆã˜M@€X2¤‡ƒï€;í%uÚrz˜Vy=Õ†›»=k%sIS´D]ËIÍ¡‰ô9AUÌDÑÃÖÔßø f%«Brˆ: buÕ÷Ø‹ÐÕ¯Ô7¨]‰žªâòEíF‰¸!çÑmï&ºŠ‘#Å‚îþЫ9g¨û›¢Hcÿ lxxdì_µYdõk­ÆG;ý PÕ)G™ø¸R•‹«wR;Ѽ¹¬Lû7.ÿUŠ{ûÄø¿›[›<üÿ­þןhÿ_ô×¾sG§'Óa¬-ädý~sç¼Sžìô$ŸôÄm!hÎÝï›)ÿuº‘%î!/­·e[/hÆå3`äÁý§®ñò—Ó¸%eÚ¯¼PÕÈ í‰?˜×‚³2.W Ìb†U>“H…•?$9…‰·ýˆÎéâ)Jž?Ýžß‘øê SegÑgÈÍ.}ÌùßhEŸ¿ZúÏâñ§Ìÿöà¡Ÿÿieÿÿ¢é¿IˆO{$EÈæ§ìx™Hê¢pÔ/m•©]L­KˆáT›‘á~ÜvI¢‚æ]‚„ÃÁáaGßZÍùýý/¢RÁósªÿ…ü¶·¼øíû«øïÏ«ÿ¡MЯÒxQ§ï·°»”†¿­ôþ\ìpÿŸ‡éχÏç:РÞ;›œ\< Æꊧ¿$‰ôF]så|`ƒ¢=íòÑ=) ç šígã>cM&=²kè¯-©:üSq>cɦUÔ®‹'Óc\š\é7m †YC"~Hõ……÷QîáÔQ;¯"ñ•Ë`È€§·ÌÇZ·ìjµùB¹oåb™rãçi1t¬:)T L{¬”ÝJ5›º'·!±OÎÄh ØvÙÞäÚ^¼ó}d«´ÄÖF·{ÙôôlÂȘ%©î¢õ÷9E 1›ÇU8†U +p6Xv¾„²óü*J°¢4߶zgøLÍÐp^röÌôT?|°×ÑÀÝ›%• ÞkçGú8;†‹SEŠ®GOÄLÅ®§Šú8Ãá <$zT€íüú Eƒâ$ï]ö¹y8¬±X×´âÕ³h#S:¯yömÐàv%}8xµÿD/5¸Ð?ö$0«Ù5HtÔ·Ž½¹ïœ3ø8û'ö*&ÁO[Ÿ û9r>VõΖýì'Þ“ÍnÝ17|î,ÈMì TóÅäìÙ°_œœä mßCó/ŽÄ¬^µ:6PÐŒ®4Õ2=c«G)­W‹ÌÆð]u¦2 “³8¢*9hK]ŒžWW\¸c匩'Fs­r:I±a½¶¦4'P<ÔZç"®Än4k´&T(oÖBÄ&ÔÀB‚•iŽ½ýÉ{œ ·2ê((°QÞA¿${“ÃIª’±lGrËÏ>- ·•iˆ6ZÛ¿¶òŽ€äÿ þðÆ€ÙüÿæƦÿýèÁýÿÿ'ðÿŽ¸œ P“ú¡–õôBSéü± h¶ëò1û„0Õ·º(´ =F,HQÈLl°>^—€­ËÅ·Mëßë˜  ‰+<OÑÖÌ|%0¹ •lUÖ2B‚UÛúŽUõ+à5u#‚©&yßoK9¿€ùn)ç‘EWæØú…¸ÙS¥ü¶Î;Ä& V&ïÇÑk±â=ÈýXN'±û­ô0ˆ,8ÒòóáËNÂÍR§8ÔM¤+«|L¡Úòeàƒ¿–ÿ¸ã¨x02ñ¢Q:Ï‚Zscryõˆiä'ßPv»×MO~þõÅß÷Ÿ‚›Oïl:|“÷]'Ÿe­Ë+óG™æèñ< °sð‡ùi9) XÐN ~NˆÇÃÑt²Èq·mŸa/ ‡Óm ¸žïDßÚLÍ1ϦIp܇{‡¿¤ÿxvøsúâe*˜ïg‡¿§?¼|ú»ÖµP/­:ß›:¤"ÒP1}-3ÔŒzŽf$`>¾~Z!÷ ë«iC®¹lÔ„­Ù8Èǹ¸èªÉ}‹(òKˆI¥I| È-h¬‡9}pôÿÕ(FäŽ9(h®N¡h”õho0²ƒ‰Çî1À/{J¨)ùøíС†¡sútp¨Õf¯¦ZiOV‰eÀõÕp{å`éÞGàÝWº€‡$FXF€€ÔÇM×Ê®æZ°%dlXÛ>¶ÐôèkMj„Ì…WK§ÄË¥=?:\£3_nî¢ :CD]s¶fôHíÔýä4Êñ–"‡7/2})%Pq”Š‰”=³PÆK†ySš¡u×ÁRžWr´ô=²ÌǨVšuªM-ðâËjZ‡,œSïŒYÊžk(ç9µÐ!³à¯5¦ü ò áÏûEF:غšÈ `ެÅä§äÃÓÉDVÑ÷ц9Fãc:û QÚë3D­µ– I_ÄWG½Þ{ò÷ôÙ‹W¿Š­bÚ¢EiñÍÞÆíÀ×Hh³IT\jH’ dýZ36~wTba$Ï-¾¶š°¬¥6gjÙ<}gÉs+5±¦Zqø ÓEz ½)Bm[H©ÅDøNÐj34gíà a3P“îuí"ð—¯Mm#ý BXöD/ýyïàç®W5Z´fÝ!ñK2Ѷ·Â ƒåÍú­:9xkR˧mvGõ ˆe¾{Èç|Qßøzõ,6*ˆÿà~„E¶«³ð3äk¨Ö-^º±þÞ§AeûüK|ŽPIŠ àÄ”"@ bË}ø`½`á€qÂ-ÉŒ[È©X³ñe³ž2aõ»­šB® sÝÅ’N2ç“Y‹díf½[g,É™íBƒìCîãèƒýäƒÿÉ 6c‚\…~@Àm“%?“îX‹–riÝ!n”ï»îRuº’ñ¤†Öœ†%V’úÂ×"5¸ÑD›Ê¹¦E»ÿx{ç^Gü+¾Û½Ó⚟š‘2÷.†ý8—9!>¿¤µ¾óîÜLíÜܵðHÅÏ¿uþo»ûínkWã6!5CXÚsÈËÖ j Q—³Hг‘¿ýQ}û?;ÍÎýXM6ÝæéÝÉ#Wz¹`œN£ÿÙÙˆ·M ØÒ^+Wïôš1–8Ô.Þ‰ƒR7P˜îqçÿÞéÞùãÎ=w㪗 ›³ÖÛì:®ÝK/AÏ’¶#.‘êˆîúá<œXz—ødrJ¢§a‡þ‚ÇÕô¸œQ;j4Z]K‡º2ÿ§ØOåq6¸±,@óì¿7<ûïÖƒ•ý竳ÿüDÛf®-Uj¬”Èk*¬{¾÷ŸùÓë½WûR èj–mÁ)¤½Ù}`ÔŒ]¥ßœ^í½Þ{n5À<8„hΗپ0J<ÿ ‡ÿóà?o?Úòì¿+ü‡ÏóÏzô›üØ ªhío‚F—B%3…nŽ äOœ8ا²š&ž{#öBà6Ù}ÐD‚‰8/†à!ÛÇŽµõ5ðû`gÉè®z‰¡<±¸gBºÇTä5ñ_§øt\ÄQŸÆ‚ùÚ¼ìÓq/—5Àú¨¡4€3”nÀ­¾+ÖFÔÙ¹Øıä¹à2ûÅEÑ W$C¶xŽÈJKᤪ¯±6NMÙOžq‡B(ºNÒ W§Éz¶•Ìtâ! 4¿ªlÖ â˜UC!«9ºNy¯Å¡üæ+ó'•pĪ(rBd;zÔù›Ê0ólãõuhß„"ÅœT“꽤Hqîk‹žMÿïuÙ[aþÏæ}'þWpVø_ÿWC¼ØoÐ 3↴ 㢜VŠôŽóÄ :Ü?Ÿ"F3N<©ÔD"îÒ±¾û›•zó6ï“ž!%ÅÚe5%ÑŦ×Üh'%¸ZÀÝ%‡¬‡ñ4¯&kMË4êÎË+þìD-“Èe‹:.§!¥Oèn~°ñÒ€¿avª•]Qšî'e” £“価%z,Dûóý‡ûSÁÆëÔil%zU[ŠQ4*A#WdI\U½Kæ—D w£ÑŠá®9ÉàYo²ké¤pM‡exË$.2·7ÀsÍí.hýx¨\VŽ…Q¾!FRƒÐHT‚ ±‹âÆâ€Ù:Š¬vèkÎbL,=»ÁàYúõd톦{¸PwqCê#¹D¥Â/>D¨Ö3º¿ƒ®ÖæX(ÔÎ Ô#,9Îi´™å¸ÖØÖòµã¡§ú;ÔmCEÒ‚½ö%ÄMAK5]­G?\*Á€ƒ™S<¢R<+ƒ?RDâHnBI8‚DNGmÁc‚òd@÷ÄçÊ)øy‹-Ð{#~–'D(ª¨Yå¹MfZÈŸƒ]pEAM‹!¹Ña × ñMŒ–ÒçgÙEÛ úCç¢~·®?ì6æƒÔƒ;/%=Y„#–aVC{;Ù[°Ün0ËÊ’…“²p“¶ÁùÖ­ß’ktgÙEÈÊ™è`: ÏUqDj²ÑnmÌ–NØ WìƒFÈeN*•ø?Nÿ«ùÿë1üËùÿ?xôÐåÿ77­ò¿|üý{½IȬ"RôåûjdyãabLxÇ&.ÅÁ{VKÎÙ{WÒï;‰e„¾¦Ø‘xýœ_bÞÎáeœÝí•åà®TBݽؼó¯Jñ,7-ÀGÑ„„cT`ñjzÌ5P–Ydà©–µËýÖ6Ò˜%Rù•UJ:ÇP)k(_›ä¶~ÛñôåkÉé²½#}½ÿÓþ?£ƒ¸÷ÇZ¤›ìî¿7îþWüÇÝôÖúÿç›?þo÷În«¹›Ü•¯¾CykW<úãŽzöÇ]zúÇ¿ cöÏ{)€{Tý„º¹çT¤!»5¡iVÊœÄ(37”Šõ*CX´9¿€ß'!(:Ç Ùp.̲iô”íô­ M2Ùø®5C)§ƒ9No51µg ‡íxRN‡úná>q;ÏëÔVó©^é(Ôu[Ç}%§Ðð?5ùTfŠ§â~i9jöSX¨r4¶hÏ!øÊø(³¯&XàëZ‘%ÿ·æŽù:ów§ $m•51¤WȆNë8)Ù?8«ðŠ* 4´Ô.×éÀÃ;ÏOàòqƒs>¢ßXíž]gv ÖLûÿ¢3t›±rÏ7Ð_fQ¡Í³]ãË7_¹Ù`À·-]#øØÝØDÓ, ¤,[sÎû[;\q¹ûw&ú 6üÜR'M…çëIá»ÎÂÌÄ ~!r.âçð‘TˆÕòÞä.ôz:œçy0Zhî Â„fÄ1¾xûÁÑÄÃquXë³”Ig‘fgšoŒ§~`­!áSÚ‚ŒææZ…´-Ȩå[…”QÈ(UgZÊ,d´÷© Dó?ñlc·¾>КŸrY&M6dÌ0ëÈ@”ÊrgCô8œœq^ }uÀ™{|õ‰Þ­Ò›’>¸•Ž«éšq|»éó 0F½9C‚i™ÂÇŒAÓÝóåŒz«û§î=rwu} 2ý™· ¡3½NšÕ9ö?\ÑOœÿùþýÍm/ÿóýUüÇÊÿoŽ OÔp“‚Cy…¬À8?//P¹‘ïÈÁ[TÓ&¿:°!âxUð<ÖõÀ¡aqðã5Ç{JÎj!ÙqMFÙðRûéÿ´iG2­m´&=`õ¢"_«á]²ÜÏyß*Ó<+NÏ`’ç¥àËs•>Bõ½-P6 c<Û€™¡¼áÓ ¦µcüu­’¸Êè˵œª?¦Zj¨î!fÀ¿Ò6’å ÝÇC^Šu t‘“ïÛáÙçu¤÷TöSX…yg»Z,ÑöBΓ7žCkwA×BȤ±€ƒàÓ¶9\£Òññ…ؽ?‚†¿a¸.Ç”\µÈGë–ÿ3m,äOxî„s0?hõ ¢„šò ´Bå‡h–0ÄÉ>êeÕN¢61ŠÓÎÙ9¯é ŸN˜]¹›}Nÿ¯°kÏ’ á¼ø¿ÍG÷Ýøûâ?+þïóá?Ã塹;’KLÎÎ2hÐ%úÝw˜jÄ¥ž”ãqÞ3]»Ë“èLï*¹wï´˜œMã^y~ïü_¢·ªÞNà.©ïÊã{癸±Æ÷`SÂ;?Ò^ˆë¿<ظû˃.)[DlZ@íã™i¯Š‹|r—ãSÌ<}o|Ò{ø×û]¯r µ»û Þ"lk`\ è,ƒ ´À'þÿì½y{7’8ü¿>E[Ú Éˆ¢_¿—EVgâÙøxl'³» —Ó"[RI6—MJÖØÚÏþ¢4šlJ²­ÌpöÙXìÐ@¡P¨»Ò —$BI_IȆ^ÌÌïlÿ}òñÐgåÛÎfã÷mëLóÍïÿóûVwã÷»×ÚT¯ Ñ…~¹ÿ'ô³ù·«†ó‰ƒèh¨$xu«b-×áÑ}Ž‡èDm_õY¤™"jÛ(}×–iu©uE­ÿ¸ôzvã ðôïÑ£_þøhÿ·’ÿÈÿZõ¤þ„¬…ècCäþ ‚ü2Òµ \¿»bõ†'^«OÝ@ºÖþ×ÑvëÛíôº"2Lb^J¬×‡ï~î>ùÓ+%wÍüðAJvâ#"‰“uzØð ÈÑ·Àçë7ñ½Ìl£Wkö-@!àªÏêðŸ9•+ÇiÒCß™œnÛùNH-@Ý\G#×Ë)Ðëÿ"!âftnOÄ¿»¢z±÷·˜>¼£ˆØ­ƒówkyð›¯&âÚû¹ØqÜKn¯ðwÅûïñ/ÿËÃ÷W÷ÿ—”ÿôõ¾j_¶ÊëÊ9xäfh3˜’{q¡Ðþ8à l#d§iOÝ”§“l6fW;XœGÉ`ÿæJ®‚÷J4f#õõ“ôt6Aà Gz_’Ïâ1èüOÝ-w}qpEƒ’S`š†ÙÐM}é>z©ç‹çIÑ3¨KˆŽ m|ÜŒÚúJZs“«À[kOÄà 5¬]FÎÀ¦›ö äõæçYÌ¥êTCö4ЯÚ̆Á"L?lk^—êïB©¡–µú8ÜÄM¥$š¡ºé/!á!6jyÄ™©XŠàOGÞ tf0ôÍÁ ó:=“Å™cÔ1%v†Êšj^¨®ÇâuÉzOšûU$…úm.YC7¢7‰Ú‚D³w° g'ÁÜ{šž'Ìt h3·j­P×¾CÙš½ļГ¥Ýþ{Ùº¸°®½ÆÑ%ª±Ê÷ªËÜdŒ×§y KáãqýÂÌvµ×¼øô_²td0’N#×;Ç ñ€&f`uVz ã§`GN„n–‡íºùÑ!¤í˜qøŽÓ8º*NÁ|ËZå«¥{Ð_òÜK3 ¬ÆJð™åNü~Û—%ý¯ŸÿíÁãÇ÷W÷ÿW¸ÿùçk[WÝšûþ7Éi ™®Ôá—*DW¬ 8©ƒÛåº[6·¢÷P¤ô™m·B»ýõ°é5RâèÂv†ƒB›ÿ †K*€ñÜê…>Þ乤€k“Ý ~.íh¹®unïÃàGËêóø•“ÇIÏÔj°=²=;^~6ÕÁÍ—fL»é¦ù5e““gÌÞW‡Jk£;_YëþˆôÎÖ-_‹òÿ>ôõ¿»?Xåÿ¼ôŸŸüÅf›ÿÈAz0¨gÇOzŠruD¾Qô’³Ã0­A÷¹YÃ0­˜bccÅ£èÂè/o_½D¢#{±ŸƒE‹ãQrO²ó´ÏþîQ± @)ìzA=~ÀŠ8Nh§Ì!ðÇ£z…ó¯îÌÛæžÿ‡ýÏÃÇ«úÏwêü[¶é&Ç_Böâ¹Ç_µZtúÿóÅ/wâð«ÓRûCs<òüß‚©÷:çÿþü÷àþÊÿçëèß$œ!×Ê"дŽŒîЪUM6g£ùQ=Õ¡Lê“ø¢KY¨…~ÑWAw Š®ÐÚÈJŽòÖvl‹žmÝu-¤ ¬4µ'º$ùç?õ+ÓM½sõ¿ âÔ*´}3¦;L˜®ØrLÝô¨m_uŠý&Y6í:(4v¹{½-4ŠÝgy’wABKOÒK‰Úq÷Þ½º„N‘ôÍ7*Å+'ü¸Ó *XûûÑnÙ÷`)Ú̦†~Ï$nR,<Þ¥˜€ h¶­ŽÕù¤Ùý»Yjlkà"3âÿEÛÿóûÛmçÄ ×¶kÅ¡á‹zTƒxÌÇ4­Ê†Ìg'v+ÓùEëõÖÆÇÂ&]5t°9¥ÿ¹„:(ê8ð×c¯ßZ½ÅC6jkÙ¾Vß.6ðýÉ4œªhy©@šÑn7Â#Q°°¨õðæJs´½ÓUØ‚£˜ÆŽ—µ0SÛ•ŠÂÙSÙ”‡°ÓÂüd½©Ó^1F5¼5³­%çÀtqqÓë ™|©Cñ[“äï\wž·pRl£«ê9„\Í×|Gƒj üÝèÜè9#¬ô<Hý]û GíŸ_¤þËÎÞÞN¡þËãUüß×”ÿ .-¿y(´ÖÈöM4Ëh…¿°Úš^¯´ÂwòüëjV·/.¬ÿäÇÿª'wVçÿ+œ:é\-úŽƒ ߈k˜ûåõ›g?=‡5üibIF¤qÞ%{i½÷\O¶É…|r‡ß²…fŸ˜bÆûhjëË:´ÿâ&³àìx²£lPÎí>i™ýüDRH¡¦þe1Õ,¤±VZáœkŽúõÝó—î¾ùó[k‰‹'(Vè‚©Vé…äurž¸Åªd¡*Äì|N‡jŽ´~‹)Zºq¥±æ„°B“dÜEƒæ½:ôñc:¢¨l“Š;¡&ѽ`:ÇDV]ðqÂôIï›Ñ¹M›„épÙUõ=ó›êÈN‘«?øh]5ß«¼?zØjmív4wÚ­5ð;õoÚ½xœNQ¹§=l¶„#-Oòè=x‹žÖëãÖúòôŸä´/îÿ±»sÿá#Ÿþïì­ü?¾Èÿ¼øBú§üÁ·¶)ªã†ñXQx‰ÓA℘Ž.Õ]r¨§Çªï»I<Ê•àšINRèèL‰áX÷ðÉ'¶®2ÿe]#fãdR·=ó´ö£F½—̦“x€E‘÷mÝúý3_ h“Ÿ¡‚?¡Ë!ŠÃØŸ• _ãBDº•»oo‡äu꽂”n Í_œ8åêÄŸu¹(ö.D¯Ò±I"/L2Aº¹›œ·Ëbw9GÔ ë bC¹ÅÉÝúÉŠS¥ã§8:f3§vûôºð–¦ ©|×Ýøˆ­®¾ßøH¯yßáB –Wí`%õÒi»0 ¶*^vO4Ä!Û¬NÂåìU<«ßuœ¥€ï‘^åU¢Ðu6ƒN5=Ð(0fžg½Tñ.]‚µ="!Aˇœ³ÿƒdt:=»ú¾z4„Û¡c ¦¥0ò@þgÙÓ‰z·ùüßí(ðÝ¢͆ÂZˆ8ÄÛANÈýÌìfÚ‡Ø)æ³h€"s’M±=øÈ8÷‰‘(ùôèÍÕ<:0IzÙéÈ('ÓÑxfl“÷µ˜ÔÇèT1½ýKÊ…{ÀÌwdÖìKPÅi71ÅËè;|KÛV°«ÎÚ×t"8EKãž…;œJ3’Yñˆ]`ßì)DA¤²˜¾îc)mz"p2^à_qØ÷„­úËuù£Ò @m¿Ù·*qÌdhpsØðGxÆÑáC=†“¥š„vÒ¥Nð­´(Q¾@íZ.ÓdàQ&tkT7ø{=U°®û5‚TÕÃâàžøð×RSù¨9~«Àaö]æLú´VÑ¿° 96ÖÜãhú^ë¿!ò¬ÎëVƒ! ¿êæÓ.#4\Ÿ½i\=¼Ã£ÀN V?Å/Õ• …F’óx 9¶ÉlÔ=I˜7…¢´AèÅk?)NJ2Ø:0Èz ØO²žü@yRþ8¨BÙCR'c2UÃÇ5@s^ûkýǽ=?ÿ«úµ²ÿ~Yý˜Nã©,ù˜)ê0ëM+èYÍWTðEßE?òÀO¡MýÕ8½ÅaE32—%“ú·Eí]¼eJFwmV/õâi‰Ðÿfh{ã„Þ¢‘Éè½1…³TwÉPUO-,P¹Z5j3u;1gðÀÌùÂÈH­àw$…VþR+V{}ã#4¸Ú_o‚hÑÐüŒnEY¿;ÍнÌÉRm§PÊ0ØÒQÂú0E17¦‹NfÓ=M¦jBOxFë /ãG® Îÿ@§§™‹ýšfݳTÉ Eü9ú,ÔÕ"ÀÀYªuR9-hŸ‚Fõ{—C,6¥!ª«éÏŸ›—{U€½ž=ÔwÓ5Y|˜vÃòôPìç*3Ûêáû_+…oѸèþ\ˆÿyôpgeÿû²÷¿"™ñ¤„E°c$Q´t4",©Ì ¼vÌr?>ûéð×_Þu_¾{÷ìÍËî«×ïž¿zùªð*b?›¤Ý~ÒËúIE¾&¦ÕlGmüdtåfÎÖc½ýõõëWoÞ=ûQÉJ¯ßýúæßÚ:nÚx•;®)žÅ2›¤§é¨Iþä`»ŒÇJlOèN_“I ‚ÿÉÂÈRæ.sNƒÔ6ŒHèwyDáúî÷D›NÚûûºJ¯ëGCZn°Ànö¾{BËFÓ'(@ávhŸßœñÄP¼.P °Ÿƒæ…­ö…Á&dxžØù}·Ø“UE  Ð&ªÒ{Üy­úšGÈ°=)غ*]ºÞÔÖ¼TÕjb%˜í8ð8Æ2Ð4#¤Úÿ ÁøïbýU÷ÓÞºçl–·ùzÀ=ý[èP3ÌœNS ø­³Œr}kh©Ï‘›M;Ü´‡}Gz©{ó-Ao®N~xå'Tp2ó8Ì2³ºš6Nö$†î´©M ÿO…|äj£¿Ž: §öå7&‹›Ú½œoÅ.åN ë1]JiàÒl]áþg3õmz-¸ÿ>|´ëßÿ»V÷ÿWôÿáÃ-…:"Ñ6ÌJý€K±2 ñFØÁÚò¬«hì›ç?À_Xïè5¸8Aª~Ô·þq¸õßß/¾ml»ÃÛW¿¾yú¬ûË«§‡ïL±$ìü?õÖ·vý÷>”o«ëño­ÍƒZãàß¼AÞ½9|ùöÀÌãm$ëšr2G›F3!â‰:´ÏtDxÄlŒ}ÐOòÞ$E "žB6ó.0N²/û'Š'ä6àŒ6UB¤l" £÷غ«ðó O¥åSÉYìP?â1°7h˜hF쀴du¬ íŒqfŒù;b€ J ý‰¤ºæi¾®ªÀÝI@|[Ðײ/¦F¸†œ=M†i¡‘lè¦}øÈätF·œ™•13Ï[§Ì”«TúH“”µ¯vIéBo[šßE#k?Dµa#raâÍÎëb”&º) î6ZùYzâ¸1è$G¢C§4¨Í_°r&ksæØÖ]o~Mÿ€¸ƒ·æï‰ÓŒ™5úR;*:ºDìÏ"cÐÑLô±g X³ÀÙ„þ¾šÜŒàœe «ï‡ôDѱ–ï²æõ‚ —uõ_·èjÇcGIîv’ö©Õãë–lÀ¨ô-—ÑùTHz êGð"ÑOBÓ(f-3>ä,å úšW!J 5bhË••¡ÜÑ ,*`yŒü“¯KƧڙ¶V[+«òÍM9¢«æú‘‡î~¯\´&Ò-\‹´"àê‚&9é‹%:Î0ņü‡;Ÿn3¢ÒôRM&ÇÜl`eH˱V‘l„†Hð £Ô&M…ûcªæâí+Ñ£A:²ÿ­nßÊ{ñ¨fµ­“t’O×¼lè?¥pˆÖX HóšEMÎ-¬ž‹Ò»fr ÝCk‡„*1wëÙ«·klkno|„é^µ1e>­úÇÚ꯮ ÈaÌnz]V’Ggñy'ÉHLqv=¨Q (ç „z3õÿPófqe Ãgÿ@ºu+ÿa„xj$ÛðŸîqÖ¿ü"ñ¿»»»~þ—Ç®âÿ¾büï[À8žˆÀOþõåtß>ÿoP±î>êÞÿtb4êFgÉ`œ£…+ÔÁ³Ó3Èÿ/ä9R(…4±È¼¬y…|‘LèìÛ¥*ϳ†§ÆܬÐFô2Q’aSXã[õç;t«™Èâ&otqŠ}px·r î2Ó ©^6NFu"¤µÉqM«¢Žêâ &WïÍFà÷tÂä²_·ÒpËLk v˜S<8Çýý:fwoxTzŸ’¾ûìåÊhøÏfÿóé¿öR»ù°(ÿÃã]¿þß΃‡«úw†þCQˆ<…JELÉg9` €”“Kãјsi“‰•eVn”é‚£„F8† FÀd+‡™ú’- qPÈ@Çž ×e{‘¼ñ¢häeß,\&Hè^¡,Qr™@q™`"»¡ËäÙÿÎT·é¥Î.ØWÀ˧ƒK¼`¦JÜÌ[å·‰®6?—Ó4öæqK8xþs¾o‰,:ÿ|ûÿÞîýûWçÿîœ}Ú¢ü,› úÚ«N0sA‘PtmàÀtm‚Óú)ÀiÑyÖ|˜ùÊw¡³¯#õ¬æÃQ¦£Þ`ÖOÀ{m<Š¦ôÄÕVîGmŸ{s”x¤j…9£7n¨tô?LŸuŸ~9ËžÿÙ4l; þnË ¸HþÛÛ¹ïË÷¬ÎÿW<ÿO  *l®%=z„®9TYÊè[/©‹î݌ʣ%“dDÕ—”äøêå»g/ßußý×k´•éJX˜¡H·i‚&x#£ß'Ç··uc*Qþþ8Å“K¯EÖ›&Ó­|ª8†¡i9ý0Uͦɇéöx§œÔûÊ qpNNè4zy¡ÌM1™^ëxÞ¬y©ôÂÊN(zj¿&½Ù`ú‰ÿÕ~$ø²Lïœh²ÆtýIªÙ9Ï‹þ ÎëPrHŽa‘H£~É­_ Žw_þCúÉxn=Ì"úÿàA¡þƒúwEÿ¿ý6¢´G¢r&˜Sd XéÍž½üñõ«ç/ßév:T°ÐPÇÜ>ùúWÓZ'ŸCûHi—^ýø_~àž €èè†@ÿ Þþúƒl“ÏŽƒÍ~S«zõÆ.}ÔÏ&…F?½zóâЬ„mFŽ‹Ä›Ã§ÿa× ‰Ä ÅFz¥ê¿oþ«ûóáÛŸM½`Lû…×byw˜R¸7L¯Jgw¶NowêØŸC¢iè…$Ews>å4íþüìðG…_….-vb™Óõõá›Ãždi uÛ¢›ˆÑþU.'þ§¶ºŸ¾ò?»þïÑîÞ£Bý÷•ÿÿפÿPíͨþŽ'à (r°Á[/’xVVýõâQ”O3%@%X¨Ý{o|´6P(A&6§Bš¢´äoôZ¿Õ#гFKhŠÅ(Ã.iœâ¢ õÑ°§W2ÀüÝssž»ëø¼M°þlï<5Jwš“n/§Inu†ºŽit:ÈŽã|—4zouÜ«å]…´‘OILE^K†Þ”Ô¸˜‡£lšDÙHè--Eh¦®K#ß+̪lNÏ1ˆošRáQÈ{fPFÇ÷51 F„bãB‹êÚ«Ož™‘tsÄ®)Ô§;¦Êö „¦ã⧣(ùâl'@.3Ô·ïBûF+¨ vã(u¢$áeÏ 2ÞÉ*´Æpty¸|+á–á9@QçŽÀŠ©‚;f}œB©É%0#JîÂÄs¨ÆÀ·³9¾Ôž/%–' lòe]Í!Q½c‹ÝÜ~¡£B9÷¼v1gŸ°©˜4{Cb6ÔþÁíØ(p˜s0ždãd2Uc˽öΗVuÞ8ßQ&Êf½ej;˜xT}ë óîÕL΃Շƒì ô+Œ—0gXá°hëÊE2A³É{“fƒpg&O»¶¡ã$ŽŠ”Ò5‚Ø3Q§.Ò•Q«1è ùs•ìýaßñªe–Üå%ï›±Cí£T«4–O½½“Íí9K—MaÔ°ë!+x€–¦7È b±úϧÈþÝ’@Õû¦Ý¦63|d+mÁG"õ‘KSj¼Œrâ÷Êœ˜Ñ°F¸BSw/3Ä3Šcjêq¨J8ÌIªÉʹ©[t x™Æ.ÝTŒÀ”Jƒã$atƒÆ@q±dÐeÄןN`ïPq÷ò<À{:›Š†´¦ 湞\hUúL‰ Ø°ÍmæirävVjá†,êáÙð!©6’¤¹¡ã1oÿ„øóZÊ»Îü]˜¹Ô$hA S2Í™ò½Ml$¨•“É͵Wc}«< …{;Γ9nM^ˆ²;”€Ÿáa¸ƒ¨Ä%GਈK( Až:‘öçß ¿öÆ€XÓ±.>ŽA›øâóFKíérhÿoy†yop_Ék”F+!è;E¹^eÈ@.SK u ŸSdStø—öÆ~Rÿ‰üeßñè?Å5NðÊ¿5;à"ÿ¯;…ü/fEÿ¿>ýçßo,Z8D‹²Ë*â„¡¦öøoJ—äÒű´:w ÷râiáŽt‰Ò}ÝV'³(k¹âV«Ãðß÷·8ÿÓýþùüøѪþûÝáÿ<]îòÜŸö̼_Èo{’eÿHF7âŸ,Ã> s…àûíLe–‘µ¥Þ̦'þ à¢ÜF|š§ÂZh”¦œ7=ê¸uaÚ{Þc®{¯¾ë±ˆKò¶˜o¹ÒZ 3uÓg´Æ³üì3±ÊˆmÑR9Äå‚ŸÙà'·ÃWˆqf¯?·”ƒz¢£›‰Å¿û“[MØ…œ§þØn”?«¾ºßotÿOÒÞQUméè$=M(¼ûŒÀ¢üO»|ÿÝÇ{+ÿï;Äÿ¿E´€òeO%R¸ y{¢ÿ–’–¡;pO¤Pä‘~|û‹ˆá¯ÐÏú¤+Býs7‘Cä9'ë*0Ó.ºA˜Ø1³uÖhuIý¬6И7¢Mk IBŠ†Ýêèš<¸OÇéHP̧HÏ¢­ׂÕÉpnÞ g¥¡ÛH YTyz:ö2G˜`rïoePº•å{5©§ÚŽW/,[[±”ŒÉQÍ3ëú¹ª­_=¾’‘;QÛ»Eh:¯`<ÙMÞ 9H³0igGÝ€Ÿˆ£"o4¤‡$¥À›—Äü†³í aÞÿ°^' 2Î’{;©½!—Ò›805˜xäÏ ÓiÙøvæ#n†•—îÀÏ«n ¼]`Ý.´8Q¸&6ë~ÚtqÖ‰g¾š1€z·Û%4Û;±ÄÙ;N=ÚèÏäÀZˆè}òf†©Îý4ÒK?EO‘>‹Ô˜LÕ|À ²_ùÄ1´+°HüóIô£º¿fr üQTJíê ú!¬"?<«Ïðæjµžl 7¶e`#âò1VsDÁõ€Byª$¢¤/ƒÉNfƒ²ÕžC¨ lr{ˆ}'+–,©°ý¤.ZŒRDŸÏt-çI€"'Œ eÞ¬o|äß²óД¢qyôá%‰0WGœ"¿³îN ×LâA`fÔ±`<«½(ãËDL£ õW ç!q:çÐGÃâºUCX'ÏVÊ[…¸€ô¬·Ñ_sÇN±.@6ÕÂgÉj#ªç„GÒî•›“eîæ˜"$àLëõ# oigQ˜Ÿélpöœv~v¶kP"3inÖÌñòò2¢ÊL$ ¸ÇÓ}÷1ÒÍHÈÙG¸íé4·ÁñÚ?»uÝÉÓÅtýC¡ï/€ -;Î&ýt„ñù™˜w3R'£/ ä@tP–ÑÕ ©í‰Goz6ËqêÙT(C:ÂÄ4Ëkƒ„"`R8(÷æAe™/‹ ˲J GâS/‘j;~ÿXr¬/‘LßNBoÔÞõÕ‡c‡#‚å˜ HR Ø'­¾ @¤#Ô™t(MXBÙà)ç²v=ø«ú¼Örw«gh£9íFðˆ—ÏÓpÕûÈU}U-ÃËêêé*tíê­èbY˼.XÑ©»4mý„´ºŠ-(”Ð4cÈZšÀs~è%ã©SJÓÌÀt ¦˜L¸C>¸[þ° m˜ÏÈi/Ž¿`BÅ„&ä »R‹ym,o„¿%[„º(•¸Ÿã £²)xbr­·g“ èO×õ—h <¯˜§m|ÄGWë:^Æ~ª¤¼ÎµQm£FpeŒngezÐÀ$0giqâåeÞ½+bt…-/m»F( r×!¨yâ®5 "Ø…LAnyž^z Ñ€e;ô/@àáËom¿*º7ʳ9ä¬A²7„fïÜ+SqºàVà¶vŒ µ`Â`Ùëe—PÅ’E#?»úÛ‚k†²ÐT£æl²„ÓGðo‘£/ú›ÞÓ¿)Æêœ+o‘¶ I_\Ì!UW™žÆ]ŽÜ ³u¸v1‹4·c1?P%”—Æ ªâ>ÖX’SΘã¤ÑòµÞ9ŒÝ)¢ÆÑ·9Í{û6È„ÂT? :d³±z„œ‘ÖRÕL©ez†ªêÐŒ&qš'È }µåø.Ñ…“:ÚíDæOÐm‘± /JÈ‚yÜŽ!èÌ}}Š>â Û|º¯ÖJrûH¹xœ¶­Š©é8á"ÛÚŽ$8›nI=zÃ7±mþ’oiŽz ¼‰²‹fËÐ8"ò0Qv$¢8,~a3 #Õ!áÉ’dÍ;î嶢0p M²At–]Ð!ÅÔ|ÈÌ' —ÍC*Rì]®%E=™¢¬ã¤—ž@ê$¤J0¼ åi‰Êa‡y³Lg牑sÄp,n,GK˜gšÂ +Ò*¨9=QQ¨•¢gÞöô¦a…ÿýìeó‘›Ó¶e[µhE„~­d’$´˜¡‰¨Â!!ù váP”hG‘ õWó$¡èH+‹ö¿/È=¥€a[BY²ÀÒ¡YÓñŸÄq(™/70‘åð*´o,7|CËvOÊ@ºm›Ç6©–Y¯«(>šk³íˆÌ®È滃z›^«Íxn|/¦£“dÒÅgj„ºóåâ§õ•¹/GA  ˜æ™ŒcÉ{ÖígÉ¡¡X,½OÙK®¤ÞMÞÃDpüôÿ][+¯u8X~Ü HïpLêžøÐ=¨ëv<&äQ“©.µ¤çMŽrq·µ¡gjÔ¸ÃWzš8¿Ò™krž¶ˆ˜õ7ýT½Ë»âY]üÍQrÿ7 D(è™o«Iý!<桉²$F‰–TÚÀ©ª Vql={(zgIï}W¡,„BOSHi@@ä¨ÑºbìÄÛÙÉØ1H‘?gF‘…>gÂ|€H´Éz(ÕãFuÊ0]6j”à•ÓÆ~ õäúà/ÕËHåü1ú„ÑVêø·Í£YoûÖŠè*ºrŒ‚-ýU+2Öí›v¡ÜÓÜÀ Õ‚C"£và„üP/)ö7òGùZ)®Ü’)Åm;X¯ßHyYïX½¦ßÖš%½È Ê]Fa g£ÌT´SVŸ&%[©ß†9ïè‚ÔEMfdiVŸj£‹[S1’ †?SçG$E… ç(Û¾‚%995&´‹lò¤]J> po:¸ôN/Îm>Û ­k+s-¤&°J:;L?…vÐi1o³J²Q<ú§’œ%lÆÚÄ«j³Éä›dXÛlóò2›f$Ãv mEiÁ©øƒ:lËÒ¿³ßåѧÍð,W«í*^¹oxg3‚TÈ€NÒ ŒŠ5B“à$O M·bÈqcõbðkf w‰îÒpÈZ#õÖÚ Ó÷£u‡P#Æ<¹¢”߈”J6g³-UT£0…£c7P‡ª!PNfIPl9±õ·$P‘' *žV ¥XÚÌ¢m…“U§ïÁiמqŠ\#ôÞðûb TL9êß R:5i8x£àü¦#\ƒã0RΨͥ®¨ð(«xåÄžºFN<°Áp}ƒ§“)"!R Ó:‡.d:EF‰è@ˆMò¹$d?Ëx$|Ù˜…yÓê2Ñ.Ÿ7¨4A3*—®;§’¹äÕa•ÏV>ZùMÀ•/¯|€åðµ£ofjS­¿Ë‡6@ÞÚoAgÐÓ#Ú"W Ô{ðyzG þxT2£œÇŠ„¦[t#'.<ĤÃ*v7” 'æ9ç$—ð,™¸èÛo4‡§æëDé'¾ ÅPÓy½¸vä\ÂÖ¨²½ oO°²ïH]0è|‡ìºsù—±Ú^ÓM¸Ê1¹©Z& :(!ŸA8ÁgöjýËÛW/7A±Ç¾Œj·!:hÄ(d“Ü üJj:S0§ô%"áGÌ6LÖù&bÕEqóƒpgÏx§jš —²èÐj­Í%þØ;_Ò€^ÿÚ¢i9‚èKî9%gÄôïTÑ6@@ÊeY.퉶EØÁ€MR`ãߎQ‡„Ï÷ÜÅK<ê§9b ƒ4|ð‰ZÐ_¥Ï& 3oÁî '¢í?¶ÖX”ìtçÌ|²Ž¶/ÌTBÛjX¢¿Ì§ÉÐDoX•F›¸V6ŒÀ[y.•½æ‰á:5?Ç9‚ÁÝÚfÃcÿ8Á±T™Œ<íUÆÀ>ª+ùƒeÌdŒ†µª“ñ±ßäžÇ1˜v2R}n [W©Ñ‰;’…ȱÇ|Ôñù ¿q%ª—µÕú ¶N ãtĽ’äG¢àh+ÞÀ+¨??’šÕ9BW-™Oxur{XÆ‘#‚†&/pùËÞ'äÀ×OFº¨£-û(`L"Cͦ6µœÔ³ÏÉ„¼ÕŸ\=Îl„ä‡XcTÐl" [•xp5¡I6;=ãCe n£Kd§iœ:èz6¯ß<ñüÝóßžA]ö#¡ª{ ùdÒžð}>š&§ÉĪ>~d±pÿü!=ýQ}j(Ýæx”¦Tþ¨NÓ6Tz4ÏàIÓùõN½¶Oè—âEš÷ÌÏrvÜŽ@q¢â7zOÚßo”Ön¿@*CJÆ_Çjqý¤ÿSjŒô¹[¤ÎºÚ¥édÖS,¬­UøöÝ›_Ÿ¾ûõ_×}[19“u ðIÀyÚ|"ì*m5† µ&H[¨ºÀXN@3¿×Ïž>?üÅÑ’¡wÿûè/Š¢{“$¬~éÍ»ÝhÁKø·"puó5­ã?þüæÕ¯¯] yŸsaˆZâÐd‹ |ž 3-Çb³†)^$H¾cØÞ^v:Jÿ¡N×ñ%Áû ÌpíäDÐe„ø2}‰q§loú³dœÖã íáR?§Y˜ï:n¾ÕÉnAñÌ€vöãIßCþ¨no_Xœxmæ‡?`½Õm .ÚŽ:{N‡ÛÏ ,½L¦&¾ì úYBjšds6:ñ1¢^S6jÑ›Iø{gÉJõ½3Å þï9ÓÁ¨¹ÄH[Epòfo¢Ÿ@s #“ƒlCÞ†r×tMphþ&9Q@õ“áØ.œô9è#–­êò(h^¢yA›1LÚæþ ¿´¿ÖšFH¾Cdú¾©¨,ÿɈUgºœÜkTA´MÈm°éú} =G¦˜ ˜™qÅxµ´WH0l¬Äî®× Z/Ð犇jM Ôà³\±èûh7„?fIñDc2sJÀ¦PâsÑæ­ùfê_O[I À¨ŠÁ%Ü,Ä{‹ Ô¿qÜ‹àKfÓ­ìdKõß:Î>DO)žB1­6Ø›ÍøCš ·ÈåʹÓ6éc›Å-7Mzl€×f‰ºm³éޗ佻̗Y•Š1ã&Æ-­X{cýóð³Â¥KMÜjX“þÁfëVIc¤¢€“Ä!|–èúØfßøøæ' ©‚~kN”¿(€zzV¹òá˜ÚÔ´CØ}Ž¢BMsý™@LAšœ„ ""¿Ã@ø'Ü*+ÃÙýU˜‹.$}8çç€îs!ð¼,jÍ”À®†ëY».9Ûò7é¸ÿ!»—3qwí@1ù#Cˆ¹¹«Ï‚SPô¡d €‰Ε@îÕ'¤Û‹Zî.š$•¬*s ÞY±  ‡íý¢"¶Í–˜Hb‰iÄ­.2ŒUîkRžÌðª|`£ÿˆI¶îeÐ<$TŽHg$¼H$Åg§H sû›Zržü-ÒÉʧ1ˆâ ºá­¯À‘ÖLyÏГ2×ÎÈÀq€víÁ£ûYÙ=™=±üBÆz|åÃ÷žÏ<«»UPŸ{>æ½öîqïmîúƒ;ÇÇ}‰Às,êP+ÚBÝ +öó¬X»+»ÀÕÿ»:àÏ—ÿùþ£‡Åú_Wúÿ;”ÿ3¨¶ü«Võ¢Â¶À]mjNU0¦Š Z??t)Cêë0âcHùkÉòSÍmÙ4Ì/ú®ÃÍ Q¥pÏ4­.²!ÏOž3aí øo…E Œ(ãÝ)qk …œ%”ÙéT„iptòâ¼*ñ%^Ýé(›„€ÜÖS¼,`KØÉö A«£ ´‰Âð}Ç°UÕÈ!,!D©"ßf"62£V«/ðŽÊ oGçE0и¬Ã ‘›=%øÓøžo&|j–'ÅK¸°)‹{úò²¶•øײCÙ˜Î3ÚG§r¡>$ÝÀx’lM@ÿÔ/È£¹ñõ„^ÈWÈ~iV~)ª˜¤”çÉj„G³Á =¹ìb ®6&C øÒ(9˜«ØùŸ݈~Í‘ÿ•b êƒz¸ŒK”’û›R‰ÿ¹ï]^X‡vaœ'óÜ] ¾q2ÒST.ë"Gµ… v-çp0)Å“A®ÖȘ¡„RZm˜©«¸ÖÂ!¬T,ƒÄÉü"çšÓÅ‚>æX–;–ùcQ'kVóŠÓ‘-0CªcŠ³-Ò×°Ü †¨kolp<ÖôϲõFfªÙðIà+‘ßBÛêÊŸGnÆX/R’@B¤)_™ÐMÔÍçhˆù;²áß_º*´¨Ô¡Ê›s³ˆ/ÌÏãÿÆýkq ü?>.ä¿¿§š¯ø¿»Íÿ-0[c@Ë™'Nh£L'~ül‘#1â`£˜y8§i~rÉ:T´ùcºQg3`«eݨ«Ü ´óÔ¦Èü(6X–´B6À¶ÍŽB± ªfWT7ÚiuÀZ_ÁjEƒf‰›‘VŽÛx ¡ãÛ71ƒY[ý›L{­†(Db`ÈH>ë‰Pº9Õ'm/rÅê#ÃârŸúVà-þ_@Yn ²â]µr&Ò£7}m ·©1ÚDý¦Žˆ"Ç .?J\(Ûnl*:…–¤BÚtuHÜ^³cg‰ñª`_‡ÌáñE5ñlòÛp"l1í窮G9Ä„ì1þ$;VëÄdH¹Vc•—êúQðv<²ÙÑŒ°äûÇ`‚S‰!ÀÐ…^4 /€ˆ¿„—#î¦BUfÄÍÎÁrô6º·/,Ÿ(ÝfªBaQÞ–cÀLÈ0¹ºoÍK¿¹áøÁÁˆQ …ѹy6LÈ*OiçE¯9\1&ñŸô‰õ£g2Üu:™‹MD™MÁ úIü$ãÄ#ZëìøTµxp_æÈhxL‘svIÉÓq.ò§p°ÀS÷BÝ̶àmäÖ›ÿlÐö9uy€ñ®²\ÁÐhSôJçîÈrërî–t­ÏáQQôèx.‰Î¦èãmÉlά;9Õ ·™šU/»´/Ï:uyò]Š¾Ôêøÿ(GÌPÉ#BLc†¥ûÒáÀ¦ÉÎÈÊ$§»™izD’&c÷7tLX‹‹X­.öÐÍjû+>"A» ¡,°1Mtt Ú“Cìƒå]̺ ôZŠ¼. d´8¨Ûm/z:Ôgá ðÊ  g 0rÃt”•øImâ¸-yêĈ’`HcßU Ül¸¼ƒ{¯„è `ÛCYNˆbº$&Ý¥ºg£ö |2}ÖóˆŒã^ÍNnÇs4ñÂrmŸ9¥= }£ŠÏÀQá7ê ‹þ¼ò÷{ké¯(å²ó$ ·`õ€@”~®£KEÈÝ¡„³@q±~‘Ñ ÊQRãD°{àj€ü±k~âDNÖIµäÔ)õ³ –yHDü}Òï]Ö× î!H=Îa¶,¹ç¬Ã:-Rç:±_È›Ebk)ç@õ™À –XªÁÊ<2r¸(í;~èÄ8NN_o3-HÍ_Œ™ËˆQi¨ž[ÄûPþb˜êÔ+BBð‘ü¥Ž¹¡Ë Y `ÖQ‚ ?a¯;}KãHß+ô(v$m}þ|î\ƒ!¼lòq´˜Ýâ¿[ß3}d6 øvˆÒNÕýû)‚ÿ²™F;Úé8=ƒ$Ãj* ñb59e£ÚNè'ʦ`¿ç~ªü˜ëÌL–Ÿ¦RLdѾîò>¹Œ äóXëÑüûtœ2”Š¤¤KtÎ㣖ëºép˜ôQÇw–¤ ‡zg2õ%P8­õæH¨M%MZfÂÈÿßÛlùäY2çÚ¤4Hsš—"“”ʈôÌ‘¢›é†n‰[0x—Í!iÖÿJúPB÷û©WÈè˜Zé–5x)V=#öÿ´ †À¹ÎÌ’MA²&§aç‹0–:'}§>"õ%ÀبcíÀ ¬ôµµa^Ð0@&ÈWÞOÏÓþ XÓ"q´ù_Ø7؈*úß ÷cÌhª†ÿ¾øµxÒhMã1¶…ö8¿G™W6W*ïBCŠ[*âe=EOy,Ég4-Œà× />qŽ.Ö9PxV 4û©—GV’6€]aó^]¦óçûÖ’³ÜI2sn­ ö€Íië¿3ö÷¾y8@N <Ûª¨>Ïþ 1Ï·‘`ÿßî£û»~ýïÇWöß;nÿ 0]¿·`qîšLàD u8&Å×3qhE‡½éLdž³– dœòÄÞ˶P\ô›åù†âÛ7ÿ$¾hTÄxÙ‚,2¢¸©P™ÄP¬Èô2˜Dç+¡:˃žƒnýÜ wF)_ûv í}ÃM¿ 8s9J)d–ëèQçÞN¯‰þÀ¤L¬œ?§2£äÏ8߃†±—-— )f÷ŒmŠÆÀä{œX˜Iãå­TWsŒŠ³¥èóý¬’ 4`bsúög½÷ Ér”‘äcëtç´Û/0óÎ=¥Ó¨&Ã1¬¨ñ%húmÑH¦ñèÿƒÝÇ|ú¿{ÿÑŠþÁü/Q2§¬}Þû€³àCÞ¼8â#g–i´êÐÂØ7‘cs zäƇ‡ƒŽWKàÀ;á*¼óÿÌ×w `ÿÿhïñcßÿÿáãÝÿÇõ?ï (•b““® ¼q«:í)äGnÚ2œQ ¼¹„k«˜Ò:Íiݮͽø;íÈ/#’M¸*³‰_0õÊ8TЭÍf²nNÂ$½Qô ·k¡].wSwØÂbN®«9.‘`º`ïËŽ~ Nô/à)À;ö1Òs‘¤Zjìpn\Äç:Næåž“Öó±èßb²C¸N-æy;*õƒÔçe?²ÙËu%ÀO¾kdêÛÌÑwN¢bû€‹MàÌúúÕÌÚ+Má±Ù”YICî›hDV'åø3×5XIgr€+íl±8'ê<PžâÏ‚8£BO!®µÇò“ObX}Sm`Òby€çá4vê—ôme€IËåØ îNçD™M…O(Äe`òæj!R[éŒaó²Eôó÷¼CLŠ }]cHô—{Õ’ h7ÛèG:%æTÍý$OOGÂoÈÄ P×#˜:Á<ÀzÌСˆîÓ¢[©v±PGÅ;Ú,x2¤ëLàŒ¬\ˆW.ÄÕ]ˆ5ýÓ5A4ù+£Y‡«• á.Èÿå ø—S,²ÿÝ/Øÿ<|¸³’ÿÿ8ò?ém?䱫¦«°¸ä»ƒ f˜@™T »•%ݤo–ñð ­Z7‘ cY …-í=Š67=}v±€‰g'AΛóf¾;£ gÅ*%ô G`à6¸tÅ8|FÇ·Ét³‚ÞZ»4÷ ©²†ñ¥{£ÛÐ`’ýµg ¯™¦YDÖaŒœRÅ`\ VÝØuÑ£¬Æü1s;{ꊩ˜¢›J˜-+V;Y•ƒvÓu¸SÔâ¥õÖ›âñ,7’È <ù’âµ®äåª >ƒÜIÒ.v€õ9Ð&" òK#r¦e’jꌀÒ1ææq„óHq bÿzG_ã iЖ»*8NFÀÞJR?EÜJM­V¦YRú%ä"øûN$ËŸEQ` ¶âðEõߎÀë Ñ_XøuÄ΂Ìé kNõ76Hâ2׊õ }-Í“@”R°©bèã\Ïîü“5µ)¸,–VOøÀñÊÀÛ_Wi|ö-Gi.-T²O& aÓ?C¯t/qläY½{kd‘'LÎ+ááöøÿp«¥-€‹ü¿wÝ÷ùÿ݇+þÿ‹úÿÑfoWm»íX2 ÌgÓé8oooŸ*N~vÜêeÃí<ŒÒ£ÊöX²íûî¯i…]6‚( 1•[K?hÚ!|×È×Í5¨¯•Ï&ĈÅÚÕ×fhÁ$I¶ÔWOVkcþ»µ¶¡g@ŸîÏTûúë'ƺ‡éy`âº,šê½1§ÀÏðÚP©™ƒÿñÉlÔ#=^6 aW=dzcÅržaˆt•ˆèËX¨Y¡·¶4AaOuÏ­FGD²›¨)D}ÐUn`%_ú"¸+ϧ½èCð%Âø?¦«(ey*h€DuE6ÿeè¿­W½­ð¤›Mº]ùº¾à‹èÿî}Ÿþï=Xéî’þÇÜsQÅø !Ïšw!“CmÍjlƒW“— ‘^˜òàÑwF¨Ã sùqžJ‚ß«Ó –t}â .H/C)NJNÇ“‚F–n>;Γi—‹åU(dnaÐ$}GÞ%†‚¨‰5˜Ûúz[”F°b6 RtÎô2h`õæ93ÆeöyyF±®e3t¥çŸ0.º›‚ÆBŠëÞûFK]c§Ó³èûh@T±õwºÐ5ý¼Z±×ÿ ô?» Ä៉þïíî>(Ðÿ«øŸ;Dÿ ýÎ.~L仄`é¸W‚‘šŠ*{)Ò]wÊÕ·Ù³â zBÏèI'jë'+pi ¿®¬vâ™it -ˆ¿”1Ì…~: T|'ÆV³ì&R¨ƒ¬?@q~æ+¢1¨‘f·&Y6=pT¤ð„zËŽ¢ïk f× púF˼Ñæ¦í„Ž꽚FÄSݬ6OG×tÚ­âÓ'±,™‰=Qóä#œéÜñ6¼9“›"öÓ*õ6´Ú´Î7ˆ{ çª4 G7kR C0> %r•‚u» u•ñ~ðµyàÕj³9¥•Eº5<°¥X5³0"øÁ{¡/zP°ÂH¯½ \®Î£é>WÀSûDªhû,ÃÉ1N‚êç+fÞ ±7ÜWþ¿Îý?í’8Ÿv_ÛÍN®Ã,Ôÿ=Þñýÿïï¬ê?ýóÉÓ_“^}qp”©{­7˜åé¹™\§0(NÍ¥ÁªÓ¿%ÉœTוp·¢ÿêPÃ!¾aˆEþ_ûùvwwVòß“ÿeFf²Ê$“¨:!jüÔds[º%ôhšÖõÉt’pm޾Ѧ¦ÞTQ@sê›ì>Ä}´ Ù¢&ÆI‘Jt¥‘Á`l>Dz F'¸|ô ²5ÙL;0ØØ9“¡)÷ÇÓ«0y7ÏÅV?C0œ’ìPÜÇʶ”¬™V=o ¹Ë´1ÃÄ’±Žè} ?:˜½"ä4·SZ ú !¬šzºMóñ&co³'UÎtGýÄ[®#²ï-<2ç¾ܾ¤Éî;²¦ÉÎÓG#?ž‰›ÀHd©:eÈ€®h0=¤ÝÊã“ÄoþŠª`(q×°ZJ»ÌfTüîÐã@ºÉ?ow²1?ÁÙŽ:Ò®õLµhré§ä(¢D"eÔ=šË“tXN46UÅÅ8c°ëÇy–ö;ުγiHÝs]zu.÷µ`Gì¡ Ä­o Vú¸Þ¦0SˆéD:N¯ÿ“›ÀÒÑ ùì¡«•æ§ð[•êB$rT„>3Z)!b¡Œ6ÕSSìæg™úõïÑÅH*Xtña Þ·NóÙq}»ÝÞnFµíZÃó2ã×õ£Ã­ÿîl6èߣxëtø}·ûû^y'Õî÷~‡{Íë0Ôk[5õ¾[|×Ï.F½Xø¿A*¹ðg¸>µ ègX·ZcˆÒÑrLú>X,À0­ ¯ ã4Í¡š¡™EÝvlFNOoZZtâXT¬|X[ÛT{?v1DáX‰œ§É´ÞÖÊa¿«•ù X6%7ù¨–Å—ÃStFSÿiŠ]o¢pܸ±›¶C? Ÿ6ýVOÞÓkR:r´¹ÜBþŸü@n$,®ÿíÛÿwÜ_é¾ÿÏŠš×Ïc˜#UxpLâ—kæ˜Ì•ÈùzŽÝHp ßvãÉi©¢ç‰©™ªK¾ 4Ó1²³„¹ê³ª×iò&ÊPZ¶ÜäÇ&dz‰¦Ÿõ‚¡«!uc¸Nôï:¨›!äSèDM7\+ñ¿þ ™é{ê2Åoݳ٬Ž&[a×´xÅ¥ÁMÀWw³ Š‡é´„%ÙCy@Š¥Ô–sDk;{gy/4Ö&Í—ÓWB(ðÐf1°c³I¡Ü8Ù–OZæÒÊNê+]ÿ’Óœ[/4ásT²üÊGN˜d¡=v”•:h23ßÅ;«XÓ<#>ËÎqðóc愵Câ?®»‡!fêÓ0ýCNK6Á3'BløXÖ}ª‚¯ž{Cg{g‹ta‹!àÌ©zuÂùãK;èPÑÁÍ/ï6ÿxUß¡*Ž‰ÒBÞƃ4ì Ó‘cõ‰i B,XPѨ›–Xtƒ¢´VÄU`8='QÉuŠÅC5—ãÆÒ¤¼ !RlGûñC 6Å õ- `¦È àH¨XÔQñXÔÔ$À ˆ Y )“"œfPëŽK§éÈ€/‹þ üâË«ÜòÌß„\dÿ»¿ë×ÿÞ}´³Êÿ~çô¿?*Tc⪫uö¡¢¦P2~×çÛBœþ(SȪŽÇT?ưĶ›Ë–ù¾>sgXÔï¸. Ìyž ¦—£Ô¹‘Fè:Ê _±#ÉZQï#€ìʳŸCí³2J~ úŸ|ˆ!.÷î éÿþÿçýÝG«ø¯? ÿTíо 7fïŽg„FßèóLw Ù¦nÇÑW½_NÈ.¤)Aû|n âð,çòÙ4¢éI‰RT¬ÞõÆŸoõ¦Aeê‘èLn±W™B¡¨ƒ­&÷“›Ì{¼ò•©HÿCN]KÞ ã¿v|ÿ¿÷Ü_Ñÿ»Æÿýô\ ÀÑ\9¬_üÄ飈šVÒݾÓ:@ŽžÑu|é‚7„7ƒ––U°øC‘RÔ¿iÃ?%|ÿ’áKG-ÌaµM§º¾m¢¢Í•2k¦'—Ø„E †ñXM x%ÓÕz’B¸ßŠåþ—ãÿ}¦îöó¿ïÞW4ßÏÿþh•ÿýŸÎÿ»Œ×ŸçîÜ)cSü®ëRÙµë‰ Ó‹ Bv!ÓÜçp/nHTðÏٽƗ^\€%¨Š¤~èIé Áµ¦â=8o¥¼»R}úOXr#ôçÑÃG¾þÿñã•ÿ÷ãÿ_3*Tˆþ½©Òûv-6˜r®ã\íþgvvÐÇìKsÛ Ïÿ$9M>Œ?§ÿ×Σ½ÿ¯‡+ûß;ÿon5ö®] +†%|UtyjÀ …—O(ð…Î9§»#S/<ÿ€ÿ9ÏÿîƒÇÅóÿx•ÿéÎt±ÉoÛüω öƒgÖŒàØÌáÕ/?¿ðÅôÔq¡†ÒÑàÓ'³ðî‰Æ ßGpàe*0(|Ÿ~ª]è§+v©FY Û Q˃èÊåªî¢rä‡Qa¢áMÊ@|Æi(ÔlGJ¶ìkÞMæ_ý¬„”¾Þ¨$ —îA1$MÝ+l-ÿ¼’¦ ÿÉäšú½›ò»»žýg÷áîÕýçkÐÿ ªH@›£„ÊbðüíÙ›·Ï_½T´¦¶ÓÚ}ÔÚ­­´.àÿ—-€xœnS¥®àµîg;ÿ»{÷|ûïîý‡VçÿKüÏhöa›»gÉ@ñOµµµ~’÷&éq¢¯oÁRîaÈÑ•|˜F5*‚jj•±ÂÖF!Ró(:¦ú¡}]d ÏSì&†‡ë‰.ýNÑ9(‹sj·ˆ}?’e>7`£ö0þ€e*4Gì4h„Šò™v’Ó¹3÷õ'œžŸƒIZ×QÕ\}`˜©ŸùóWQïL ØðçA6:]_ÒÝØlŠ¡1»ù”âh“‹:/åðõó†}­ ò‰±*åQP©iœ`íh÷ÁNÐršLÝjÇqO»›•O|͘¼Çã5-.à:Ü&)`õ NjV5ûQ˜Am»ÖŒ`âí¨÷ôוt¯F¬C©Û.©sH.OgyC!S”üo´·³3¯ñqÖ¿ÔMåÊôZ`~ÙùRÓ«Eߪֻէø`‰)"aœ;?DµâJL"ýgÉä’Ë„VX“BûøC{¹ÕÝhOÊ tÞÂlŒ·JŸ~P—¿‚b¾„ó<„s=$£ó£šbZú,ªÖiÜ:‘Žº0¡6}- yq!“2@ÔEÝ! A‘xb‚x®B3¤Ø½ëLsi*y?R4ô.q¢Ì9¢ r|Ë–è6Ö_Õ˜/hÈÿHnzÀ¬F7Äk|ŽKߘîÈ)…ÍêŠÍúºÇ ž;4ç°ždÙq<¹s©ñ¶) u{×Ëa¨HÄÒ¬uøBÙì°‰µ„boËJQc…?%MM'oÎ/¡ÃTÅóë}6Î[mMµüjò„…Ôµnf#äìù›­“tR˜Në2#¬Nñ)Ì-O°R¤ƒÛ{w€óCÎrŽ‘Æ¡©—×6ÆBÎɇ2!ÆÆê»ï“åUÓù¤ XÝ Ki¤ËÆ\†=a}¾¡6µ§5 Ù«ÕL{éÁë¦Uóa|†\ùQí?·1WÓÖ;˜{­‘È5œbí+Ñ-“ ºÓèâ šÛÛŽ¨æ_“€ØöwÙve£ni÷yƒ¸û¹ŸÄ_“jR0¿ZàaâªÚuÄG> 0ÿ= iåƒÜ@Àq¸Ð‚WYŒïnŸä²ybÂ×ÞÏ"PŠÎ¨¶/€½s)ÈZÝÂBoÀ .· ø×>eƒ¸öÚ̾[äæÝ¿;Ëv¶VÎw‘"»\"\‘O·šѺ>Æß`1‡THÒꀂqGàô¹ˆÆ×&èéÿûI2\vyýý®6ÉßÈ°°þË£Bý—•þÿëêÿYtøÑá9cë±LTÚ’C‚’Z€nb¦Þ·³ñ8›L¡„¡’J'Äüj̲„CÉ,Ãxµÿž3ìÈBü<{²½óÙ*6Ÿ._T»í.FSG‘~ÍA‰iD$#­Ò¸8}1¼Mhƒ>ñQ{†ƒ n®ÀÜ!”~¾'¼Éåö"–‚žõ0›¦fŒ‹ä­`RÒ<53þqÞ¨8™«µ5—µì'Ï®£‹lò>Ç”\³‘Õ²˜k‡®ã…wÀÀ€0Øeïѳk™5LÝC™hð´V6×*3mé¾Òt×-‚lX0mœ5Á~zr’ ásb™µ¬‡1ý0­¾†;V„ûŸxu #nÁö_Åÿóñžÿ±óàá*þï.ÙÿŸúã,M}ZÖ¸,¦ð®ª’_cæ|÷’9Ü«G™æÑ‹f˜ä…5>VOöÁæœ÷”ñ’õ±›´jkþíŠdOµ®Éa>Êÿr`—£dÚ;Kr8Yt»_š¢bD{A@NkT¿nÉnD¯‚ yYÔà¶Î4؃|Py–›ºëãawoRk´!Êv:­l’ž¦#—¦ÐP†…³ó QdpαQz"Vçµa¬ D[×WÖg†‘]6O¨Â’p¶ÇIWMd¥ù—Õÿ˜L_’ÿèÿì®øÿÿŸÍ3ÀÞ ãUË°\·D n& |M`Åb¯þwmú|Ú1ˆê.w,Ìÿ¸ã×{øhwUÿwåÿóùüwæ“ðq–»ÔñÁÎCI!¹AmÛ\ K <¼[äÎ;ÿùY<ùâö¿½û{ùÿþ*ÿ×ݶÿyV!FSºåZ±D­=tå¦?÷´·Ç±’©Ñ™Ož|<©Þ':^ò¹:´§Â&f[åJÐ ·*ØÇDŽj›³Ê‡b)Õšå‰\VF‰æý¤7€OÕu}F2èrÔ8…¢6æQ³…f8Õ %¹-…›{f¬ªþÝó]Ô¥5ëc4ÆèaL9ÛƒFWe à×Xñ€_•þßÁ_†þï=Ú}ä×Ü}øàÑŠÿûŠôß>E‚§sƒ‚ÌrÑÑg °ée­RˆÐuÙF¡}OùúàÊ°¨ qk4=S¿NYmÊÕÊe{ËtÒ‹¨_$ÀÑmçñ¬—ÔJUAžk?ƒŒ;I†SrœÎ€ÛÕ™ÄÁô 4WÁL@ù ðh£'Å Á"\7®±ZGŸ²x¨`T’¯œ‚óèÕëwÏ_½|û…0FWò Z iTãqÒ=Ä£÷pù4ç¬V¯_½}wƒ…¯9‚ÒµWT–\ÀTÉLÔÈoÄNìú¤½E§¶Å4ÒŽæO¯C·¨ï 7bמÂmŒ¥G5m”º`9³ÃÎü*ÆșלO ³M)3èC-¢äBŽ¡-v¹"ËqrŸ'ÝAú^u±Ô_Lhåe‡qo’uMŠö’ð˜q¬møVµÀ—9ÓU¼ê—›¯ú˜ æ1œ2dJ§ç6¯Áu×CY¾Ô‚èkrEçj‚,gx‰:óÑe-½T“Q:áµ®Qš¢`Þi6|EŒß`Õœô€ÑÓ¹dt¶ˆÔ4âîgÓ鸽½}qqѺ¸ßÊ&§Û¯'Ù4ëeƒ|›ÇÐÿnåIo÷Aël:pJ c5¾Ã¯¾ñÔ4|+tЛ¬ åU#‹/Dx"ˆû†¸‰½^« ‡è"WKò8„Ð.è0 }ûCÖªÑe4LúiŒ1&›ZŸôkД€Øå‡Ý/‹µÁ/}î& ×»ó̬LŒ£6²F4)©)D²«xVkCç¢Wø }¼B 6šÄižt“É$›Ôyµž“ RPüOÙä,à÷û9%:Ëó¬—’:dŠI9β‘BðÁUcǾ¿Hª®Ú ¸±Z2VN÷@ íĤH\ ¢ÿ.hpVÅ^šŸ©×¶ù+!GE~ OToÁŸãZ}>§Àµ'q­œ{iº7ðR@ ö™V§sÏrUÂÞo«¹lŸïê¥.Çà×õð!Ayû¢eÓ<œH2Hw—Gùn Aal¡µAA}¢ª¯À¼V7!T³ûìëtBñÔ>»1 s§S)·èNP±‹ÿíBOÀÏÐÐ-““ïUžœË™™LÔøN´t4J&Õ=L†Ç^rû¶¶Íï}ÿƒàg @,‰~´î fðN嘣ˆóÞÞ»_ýôª¶…qVa·C/Ö>P÷É>ÞÏ .þ;äWãŒg¹º°G|%â ÐÈ€Q1Š,yÜóÉc)åÃ¥Ô ‡ï[(zó…=Àžï-KéË%µÎ4Âÿ~Q?UâØ·è?r}­$îa!àx`ŠÿB™¿µ6>ªGWC^r¤ØÉ4Î×]šR~P,Ô Ó\] Ô4t©±üApPzæE–„TeÑ÷Í<™=‹­L˜þC{ejØEEn&H! ÉŸÄ'Áʽ06¬¯0ÿ˜;ˆ„_¿Þ)wµGlNb–šè'žÙ8‚ó¥N0°‰7EÓ¾mílýÍí/¢aÚ;‹“Au VýÁ΃Æò°vÇP’^£L‘À%РL‡;"ïíé”Ô UŸFI|£è' `A헼蟿åÞœd™gkõ·“u6ø‰jqe»aøJû5rYö|9Æ®ü}]Íï÷õ6t¼Zo,sôÝCÏYÿ1r™—º€Ýyâ÷¼¼nµß I-\íô§n맓$©'Ž _­ öžËTP±;b_—eÇMÓ¡gJ°€ëÿp<½Ä;¾Ì—½¶í%­>‹šŸôXï,šˆX7ÂZL†'JLÃO¨n'¦þÓÓ»¥òùC‚PÃ}¶¾¯g,™w“Ñ9pô[°–é’ äXß×vÏ%‰({[-jb î|UÔ?σ7ª¾©áŽÌ5ó^ ;_?w©Oà•$Úbã9°p°S&£¤ÓýV1éwMòÚ9SŽ^64ŸÏÝí–‹Á ÁSCjÓ9¬¢ÔlZµ¯ÌŸ;zk•Á1÷UÖÃU ¤ºçÔñsW©ÙóÝè|¯q‡–ZÒïš â¢×Ýyì~»«—Cz“=Dazë7žÊMÑv¾øV3ïÞâf£ ™7ïóÕ÷ŸaЙ’K²~¤Äšã¬j[] µŽ#BÕ¤ÿ¾Ï,ªøãRx1u‡¯]£{‘™-Hº êm?å lºñÒT+^yÔKºÙItÍø©IÒKÒsÕU{•µ³Ñ%»jK5®7˜ºíݱ`õµÂæÓe‹r þ+f2~­g «¡˜ðJîßK÷ –mDð­dÔË qs~9<Îóç<ý0-™²Iû™f ;hâ ,æSñŒ1;§9ÐúÍÆS*¾ãJþþ&S©´`)i«_‹ö¿—"g¹¶œ•‹Ó ºËü¸žö×ÛëÜ{ýªVeyéHhI›VE†QÛ6W‚9"ëp§Š,âcm…¥­C‡õN­•T´ù8D%‘×ÚjMuw)±¦ÓŒ‡´v–^Æji ;EBp‘ Ž¶Z2üýÉGY|ÚXÛ…Á·ë-ÎÚ¸%-gϲÛu039jghv¥éO2'ë¬}ìéÕ¸£êN„£í*Ñf·µ vÓft¤v\™›Tè«Ñ‰oÀóIj§Ñ:ï{\5¢‹]`]¼BZ¥å¤tćpÝ×EørœH/ÐNªþ `™Ä5·Mß7!ƒÞq“¸/Ó'M\±±µ§¯^¾{öò]÷ݽ~†ädŽY‘–âæìïÓFFÑÞÎnÔŽ [ I“ž3ˆ,´eLa¯Ê J²'Þ ¦#D„¬KÒø°öev•¾õ/»­ZUWºW†…ëÍFïÁ"?‰Gù‰bø‘ep½n²½6¸ÚWÜäâ6ßîF«V?¿{÷ºûîÍáË·?={Ó}öòé«Ÿ¿ü3µgpÖÄ`¿<{ùçw?ãkiJ¹mT¹Udñ¡X1c]ð~'ÓR1¨ä‚Wì×6ÞÔÞ5OÏÊïùòá¼²A\+5 .šÔ6Ù«½!ùaG°»Äu.fÇìÀ5{ó§·]¸Uùd{=…›âLeÛÖâ±d‡2tkƒ»”\ij^ŠmÐ,ÌE²A`ÿÀàª&`²×OÉ41ÎßcÈô",®CËø 9šo-#ySq¦„Ür´ÃIÁì@÷¡g“tgg»…9AÉŸ)R9ždãd2¸„[B±‚1fOÜø=Z³q/Γ«ˆbÊ×CjCÅaåzâ Õð:h> w^tš\¢ž²¦èe­¦È¥ó½è©Z-¬š½´˜(Oª£BÞ\>Ô=™’–;Y0Òué«ã£::õ“|mF{èßy ˆ®³Äú<{ñAµLc„›áZªöÀ/¡ÏÚU=Æ‹D#=ž"#›cŸê…ØÒÕkÁÕ6¤À1b2¢»-$±»´«6oá B¸ÔJ½rìˆÚZƉQôŸ[T„wëgß Y‚-E=·K“´gÑUÈD¦!áÀÏ›÷ü:Ðè°z™—Ù4:´nÆ¥=EyXwÕJºCô*×JŽ<ú0”ÄT,دڷaF”_ ,JºSSQ„&bcut¿Sw j–¹Xv®q±ìÜþÅ"K¤Wº˜¤”!ÑB*mïY€Ÿ"x„v‡ZS@=cÛ<Îl’Ôš²ôx(p`Y>«d[*‘ˆ9©ÏúYw¤]VÐ æž™#l›Õ>ÞŠoºHYOs8&)2Ó3ºÄíhåœÐ-fPpQëú,H­°L³<$$a:R“i©®«"ƒôZx ûÞ*ÔCýLÿ¿-t0*~\WýÖŸNKoº[™Ä҈汸%.î'éÀIü%[x›©Å<Õu5FûZG4T¶áq<†¬€«²ÜX¶õ0üU¤þU½¯ÖËl"ËÚ¢r+@`ù@˹ˆEŸ¥ƒ¾u¦ÉÕ!uBç­}Ï·"^Øzé¥ ˜–¹ BéÔ‡.%·NeW$Lúï¬ÎŸsþ@OVO£Íýh·±ðø•4ž¾ymñð•4¸Õ³ßh´ÀÎÌRGOtÝ[ò䉮÷—¼òD×wéÆ+j«¼È1_¯^¨GAÐ áñf»ù_Lûƒ/J«î"Sõ¡B„-~Qqœùvîº4s7ªNÇõp1óhÁó›ÌEº(ÃX•'ä©Ù- öYfJ8Xå9åÉ$U”à˜<RÌÙÁ–lŒéì¾Ò¤ÓQ<¹œ7SjqkÓËzÓdº•O'I<œW "êQ‰ŸtæÍ3×Û0>Mºê.L@ÊLÞÛZ)ðR½øIýÓÊÆɨîöiª+¹ÿ›¶šWß—¶µK}8\á_áxxÞñCê! ç}ËÒ|V‰®ŸÊò–Àæl q´Ù þD°¢×!Nßn üìêÆjCÞ7“G˜{ñK½dEïò.½K†cø3¶SzÃoÖBSšóB“Ir‘=í™0ëÂoÚ¯»{³ü¦°“ƒÝ–½‡ó7`iz]q#5TB¤ñbÁ†2òØ-EÑSµGÏF³a2‰§Ù„‹®DŸŽï­¹úѺL“AßÝûZ¨A!1PÔäMÜ{ßn?¥X•àÎj¬‡ª4[9sw¹-ÅRtÌoÏÞ¼}þê%ÅÄÀ“íÝÖnmíKláBd¥ƒŠĽ³d †™d1“Q¶ÕƒWçñŽ#«¶žéÈ*;”j¬UÅÊõÞï“ßGàwþã`<ØÿÀÿ¯W¾ÊÐ^8Mo)Èn^¯‘g ÄlÂÎ`ø¶B„‡;;>¦®ŸÇ·p>‹Sº¦@@Zåår,XÙB³P{ýp>{½6á€Äj\éBY/êÊðFôšxð!cXm7_¥öÏÅZW˜Ê$¹9gí\ˆÚä  Ö?mäqüÖ"³Ôõ qš‘ç[»e9²|Õ“à®öæ‹,ñpÓãÅQ=º"é(YÉ ËMãE£x‰¼èáÜT^ºßÖ÷õ®ŸÍ«Æý-üSÁ |u©ãÃcx'Èó´*è@ú¨å/úæGÉqÑÌ‚w‹K1¿ÄÃ8qÅëWL(°Þ©„j\'e:U¬ÀP¦¨·¼; R†F¨GúÞtüpl·/ž¿xÖnÃÊò<èª)Ôàõë§Y7_ F3ÍꨲœmPùš:[ÇxIjÒd1 Ôr#T’~´‹!}´'¯þ©Ú–“W*T]·°ø“Yþ·û§R«m||úçç­$ï)™Ò.Æq9ðà4e¦Óùo¾þR)™¯£ÈÚtöFd§˜MŸd²·õÙxÅ}Š|ìg#þ½~ùgâ¨ÎSˆ~Tý®¼”Dfù¦º7q¸6sßï?ÝnÿŠOú?iI­ RãƒmZ’¬X9Ïî‹Xo;…凒8bFœ*ˆëòsóµ ÜÛ4û´Tú„(Í\äªà÷‚ÙÄJPæÍìøÒâRÐíþôü—gÝ®›-ÔA^T¡T@±~‡ÅÙš¨IpeYL¹¹&’æ±ìˆ×@QQ ŒE—ň²4š„S µÜÌÆ Ó~\Ä‹C,µŽÓ·êÛÚ„Õ?^Ÿe£Ë¦‹“6SƒÊ3©+`7£oãÉi.OÉx  þqÇð”kôñC*°¨åfðw÷4=OFaO3˜ÍêÀ ù7Ð&Þ‚/«œ^Ž:s›|÷M7Ü'ƒW™žÍ×[U«89 *DžàÀ¦xâ€màœQrì“I6Ô…[ÂYAÁÂûÚn{›Ù¤ôlÍhwï~Y‘0ûYÃÖU°Ó S+¨nx±(Z dà‡ q×_’\Ë@X¶Úl–šLw6wöfµ¦8íÊa¾öt* ¤€‡‹èçÄÔëlÎÍm†‘3?Ë.¢Ù8ÊfÓ<í'¨ %Ô×6† ,yóK¦PQ窘œæ°Hšy{PöÊ"\c¤æbt.ÙRr€ý»ú¹ÖæúJ®Nׇÿ Ûu€¬–,Ï)ÂáåÂd?rªNtÙ>@ÍŠW¢ëÁWçÖ÷ÑÇ«%aò{Ý _p¬²MœåÉ_NÕæû½•Ž€y»¥í­×€Ypêy†È”¢¹ÓIvé¡·¹!|Ç䦜̼j wV{äåtÿ_‚Ùõ@8G f3àˆŽ“³TÉA£&CYÓN×Ù³€i·ˆs¿„ ðš¤~qd:(Š|µñsMÛŽjOãÙéÙT;q½LÀAN[8Í+Y!·pXeŠaÂK¥É}°LšÜz`å%1¶êsvã<í9!CãI6UŸÌ±Ê¤­!”Ñø9¬y/‡êàØI¥ÒŒºc+PÍ0/FÃÕæÖ]¢bÔ¨(ÅJËM(è0è·jžÍàE¢wHåá¯ï~~õæù¾ÓfJJ•L«êƳéY—Є\5ñ49圖ñ˜*S@õjÆ-”§Ó*¼¨9‡‚{T$½æRˆûXz¯¬ÁƒýAa)×ßòÒJd ÅkÁ¾BŠ¸ 5|(~^·¯…Ý+ô6Áß=EFr]ôTGàéÌR·næÒÕ–¢6ÁQ ÚäÚgß²Û‡xq1:sGÜ}¯nYÈs¯«Ô2@‹vAÍu ¾Â¥ ™¨Ã8ÀÝ ³È BZ]A|Ü(!Ñ7ßDcümÖ4Ÿs(ßU±©áoßÑM[Š¼]sý4¿Ù<‚ô±€ét…è<ž¤@-5þ¤@9ÁÃØ/ƒ]íl>ÁÕ‚aÄݘ›MõNmn¹ÓÁ¼fƒìôTÄ0,ô ¬ôáëç ÿü l¥’£~’f¨—}‹éÝŸ¿*©iEôý¨Ýþÿ ÃTÖ¨”Vrd±);‰hÖl³Jzâ/}šba ìh”Òä¯,·Y¿~Jþ¸ä%•—Ö溥œÉO]wûtt’•zè{ ‚¶Qm ~[ÚÒŠoBa) ¤œÊd0ûñ¤¯wEýStNKïúz+žÖw­\ªÃ wæ£ìÂ)Š2m„wCmºÓýE9Â`ýy3:ÚøH{Ónÿ¤mË[ÊË^1ݾ:Zšf4m\ý¾±ññõ$êÒ§ý«N=ùÓ«hk+jGøïµë€4t¸øºó‹• ‚‡Šq`^LË‚KÉ ? œú…W#S´ìÂKž#/2ÞØüÆ䨢¤R²üÓd”LÒž@<¸ˆ/söB¨¶þ¹‚MñÚÜõ2;ª‚†VBöb¥6Gà‰ñ4–§9âÅ5ùSÖßnDµöR»Êƒ8cÛ‘i¯úÝivPoÓg…ï¶^Y}ó妴±ˆG- „1®9lø>‚M°Ð.‡bÙHêƒv+2›á±¦rƒ÷–ØÇâá%¦ž(ÂÿŸ³ ù-£0ìÔ·î$¡b…-Y.¨! ý4P‡:Oü)‡b5”[vÔjÈW Ï&‰œâýJƒ-Bä&Û) p t]Ä®vq#z÷êÇWmEN?á{p±«á@a¯ÚOS¨R’é|ÈŠßkE?gQ|Lu@åÕ³µ4O8Œ{“ìÀ:AÃ7É®²N6ËC–oãã§&“~ˆjj÷j>îãHQ{œÆ½K ?݉ÞÔŠõÔüô€ŽÉ±Â‚åÒd.YÏÏ?mjêˇX?p† …,;Š/øò(‹j.˜ ,gÉ!öB¹ódÁhõç,éÓçð„ÆZD ÈÀÁ©D0¨¡é;™–&“J>@¡ÊÔ« I”ৣ{µEgLŒpÕrÏXýÍlÜõ3²ˆð€µZYB2„ Àc‘q¬ªmrïgW_@ƒhà.»2£wg1yå:‰îá½—ÎjN º†uýýpp­  p¾µ³ã’´<²aqœq 3 ŒPÙGŸ¬æ¬H+#¿Æ®ôÄÁ­6Ö© -vÚ ¿ñm¡Ÿßñö6舯/‚ G`Dñc^.–åêîœ&hxÖ9’ ­§´‚Ê©–Ãùô^2ÁÔœa44ÈQ˜ç>íqëh:[n µ¦“âq hÕi6*t«'ÉI/~ŸÔüÝtI°‡i±ýòBZl&Ô(‰= ÔÅ´Nµ>Ò“e'‘Vòk„ÉÉD>72!èSjýJ姾+ûÀŸª9@‹»q —ÔÆécÃâ5„Cgºö˜XŒÐ.rW¾Ó•Ù¢Â@åÜi /2 ¾)Ñ],/8}ßCSåx" °“¸÷Þà^½öRÉز֌ *ÎõRXp­Eåpsü" Zñ3yÃõ#¡«ðs¸iðë¡Ý„°_ä¬ÐrÏ" ã$‹ˆl¨Óç¹ç ‹jTåð£÷@ ÙmÎa÷õ±¸ÜC°—”Þ?Þî¬óuAzåI‹ÜÕzSI'{ 8¿,»¡&Tyœ…å?¢À1¯1¾­²ÑH}]M^ßXàî5E=~Œ§ñ±º_ª¶š ‡³Ç«èNÎþSùøÿ³÷îýmÇÂpþÖ§@è_²¥(‘’í>ˆåÄqœÆ=ñ嵕žöQøò@$$¡&€”¬Êz?û»3{Á^q!)YN¤_KÀbwvfvvvv.BAe*º—èK³r«ë·dk0¹gLo°ð¥¬æ²ÂÎDŒ4d—ÖÁÐXªéÚnÌVl¾¹ZzhÊi% t>»§Æf©!é´b­Xï›KÙ{Ú¬Ca/wŸæîÆŠ‘ÇVeüíðÃXÌwU†ÐÌ·l¶Þ”ù•0—Óçæ.’˜Öm¤àÊÁìº 7ô&ñÉID=kíŸA-“1ºzÛÙMWZ¬ Þ£a°0;ì”…¶–kÕÓpv< ­jµþhA‚™Ö¸†ñˆà]¹;œÌXȆÀB>|Z×%&¨ûÀiˆ²•ø7[«‚ë³¼:£Žý}ŒÆ´HG¯¨fË#XWÃwÉéFœf6„å®ç³QáÊ8쟃Nh:Л•H…šK…mÑEbåÛÊ« \±{÷2mŸˆ&• ¾S\•ÞÐè´dSv@`åvñÔh ²oêsÀÃ&`"DzþÂã4[ åÜI±¢Vô1Î5®sÁx‰±©6A n—²[µÕÍâuú _ñEºLøÝ!›áÿè0þæ7_"ì?6Dyà§é4 g®`‡Ù›?~û!Î {øÛ0\Urð— P@ˆ·—¾.³™;o]è g¡(ð¯8)É÷]:Xa*Çm³Õ -0ÐVTc¦…†¶,§Šã2gQUd„å˜,7±° Ä×ëzŽÓ¬×·„’ŠÎ¹åì^a!—?†2û•¬£¶©®af5”D1?C(t¥”4Y"€±¬ÇþX÷KáÐÒÝžâkhi3ãîV¢Aœ{ÔÍsóBû½qšXE«HŒúG£òŽË·6ìa¤¹é;<À;‘úá{Áâ㢹—÷g Ž ­Ì[}—mâtË;&œ³ÈÔt!nõH´¦›×ÝC ¬çl1‚©}GÖtJ3ò²À¾ìš0¼äm™Œîèr’ê-ÔD™ä}—åו*#ܲOL¯ª(ƒà³¥nv+bhΘëžt©ºHÝé]WwRq ßw]‰yW#ÄÆ0]™X9þ\µ­€²oëZÛV¦`Y·–»CØ,Ì;C­˜mq¬Ä‹ˆ¨9Ì)&Ì#!dÈï¬0,K«|îy-áKñàŠßñB­FöyKMN˜ÔË;(›îyÅnù6Õdåæ³øBÞ¸0.‘]«‰‰Ã÷(*§®s¢ð”À?v/¡Þí@RlÚ P$XìçfÀ¬Í„MØÐÎ… ùPçÄ*Δ“§6`ÉU˜²Š-©q¤sÙ—M'3á5¹edбpãfø±¶ÁÀ¡7iE|jŒö„ß·­2š;Qd½nN}¼,á¼Wp)ûwò{²½Ú¦b>;¢iÃå,ØêØrÓ=ÃÞ cp=ô©·ëÄ:s¯—0n?§TêÛÆ•·??£é*~Œ’8šà…M¿ãÂ]|‚ µkeŽjÚyɵÜT6®¬\Qˆ ºd—iãÎ0F]à0× pU懀³–YDÑ£äà© Äåì8~f °¬×: 7w‹wmfK.hO:ß o ¬¯²Q%E¸ê®ÔZÈ@˜ÌÂÉ3‡Sž~[Kço?-|œæÚ ã<™ôfù6ˆ—©íôà%x 3d²dñ–êAºÔšöȨ¥«O†ÑšZ²cÏI>LÏ Æ!hVpf¼Ü€ìI(c‹žªþž‡@•¹TÒ‡"݉ôíëš¹Ž˜ÚóÖíXdìŒÌ3§WB !äº ùåfåmÚû»j߶µÏ",Xå °Riëã†ÃCí–óyš‘·½V¹δ‘‰/ÜŸD›:'LK±zÎß~ÚÖ+…´®~k1GyÑü·Vð[ëÁmzއ׿µ®[–"!º²kBï~µó–½üˆäñ ¦¯hèWXP*À Rgrá׉ÅdµY£D6Iᙚj¡>="{2® Z¡ ‡œEYˆ€§šdb[):©ì¦ë³  *>kdRºÁ28›æíÍq µ ĺŒ@T0›M[ƒ×DE–œêùóoi}¼2²lv™T²¦§Û:Ê/×éÛvÖVm û(¦†FŒÔÀ\öE,,ÍpQnP»_.Ÿi¹˜jÅ<Ìr xL¦ rZII“Ô˜ãË*%¶ÄØÀŠÄ@ç Æ®¼¨šôqh9‹É_vaî[Áþà~þæõá‹×‡£Ã½}a"¶¡‚'ÕŽ©cøgPtìB‰9ÜiXnº¦Qg2jFÖXÌø‰kS J÷Æ+>Á*]—3@­ô —A–ÁœY-Ûâ|éXçœÈôÝ°t™)3P'ô­7>ƒ,Xñ©.–Œ ­@p6›8¤!zp%·Õ‹bÁø2†Ñ‹ß Ž“»iZÕj·ÓÀK–}4Ïâܯ,ácnŽlæ«ìŒoñӶź,=!íÐjqТvÆÖÓ°?Ø{²Cž?­ÞrDqÖ›ˆ%'¨ü‘¥Ð…4RÀ³dï'ûùrAÔ'o%ž8ë:BÕãÌO•M[±D§±Ë%&G{Qè‘)8CX‘HGñ£œ` B)ÉõhxNã ¯sÜ@[Øü2hûtþTum¯ª3ŒîF¬‘k,2ªUš¶¹B¨zí8EÙU¼ýEµ“>ØZï+ëiu·rv·¤ÁÞªÆêæ4zYMÇSN Z¾âÒöµïrm½HÙ×>o.óN“Ó Ž¡î«Nýs¦c’ç„Š8šÙ¦åñ´J_oˆ¶ûhË®ànû¶Äzb«ÄÌðo½ ëÒ¸Ó©ÌI§D{Œ²NIVóÉ"^\*‰Í \iú&éØxðÅcµZ%{&¥[ÄËúØPýºžqÅã&¬!À·:_æc6 üJ$UŠ@ªJx´¿ûW"Å~MD±¸øÖÐÃõ®áVc’·¯<²üü•^þµãòN_‘þ­{ /ÃÒeÈ,¤(MXÆ‘B/’åò¸Úà zçƒU ð|¿s¿¤©Ÿô5ðäwí“(öy¹æ¶žO1 'Œ¸hɵø—ËŒ \C0Õ)‚sFN…€øÓEû¼OÔé¸o|é‚ÚäMV%ø¼Èy·mÍɲÔVVÀ@Üaÿ–­2­¯¾Þ×¼è-éï$ƒ’>ó®ƒÕb.Ñúu ®Mjzï%ôÒÃ^ù×9Šh^ ±R6]|õú§mEçóÕdœä¬…×Èê:R²Ñ㮺¦AÇdÓ÷‚Eú!JºÙÛCÿ–Ž©ç7=˜Æ³x!šâ†'~uŠ‘|>;uIôFU|9ìaÛ¶08î'àPîÝÛÌŽâNµÓô˜ —HÛ% Âv»ã³@áÀdšÝ&áG­°Õm“ÿ[C©ÐP"SD6¬K?#¿V²["r:"¼†€›…sHØ}RîŠiÇäÃâᚧe–+§_)û ïáJÛ|NJ´Âtõ·”‰áågõ õ¸68œTô¯1´¯1ìÔÂýÊ¥ˆ§üu]Z½rå —1ònƒ+Ë-ÔYïX’a…ÕN0ÊÖ6•JP¢”'é2[ L2=GuÝ/n5 ÆWävDÃx½Ûl¤òÊ€áïÀ*… =ä)ü…A Fù]¬ÖûóYÌ:lÊ‚Øõ3ÕÝÙE@îÄGüAܤˆ.pdŸ.#ßÍWVö ÖÓI ÖCÁwNå~…A£wgùÂnwà%wŽü1;ŽøµÿL–3öí2ùv­…-²•þnI´ªù\Çî'õ¦C‚^Ä áð`ùcá;«@äQ4BÇè Nbow¯ìV˜Ñ .߃UY kÙ å ˜ªUÛ=’ TÁÌ ÙolE25¼%º°ûê¥ “Ý^4¢œ›ZckHüã0«x/J ðâ,"K0•)yÀNãó(©«â»¡­ Î[¦p)‹@½EÀ©ÕáóuMwô:þOdú”|^SìNß[cëYcÍØÕÜgª‘zøˆH©p>‡¼&ÛOÛ<ÅÉÑ Ç_]w½#ÿÕ›__¾øÑq,K^ÕÐ#ë?Â’ é«´ø3§ŽíI gé>¸ôí5™g´BíÍ ÏÃxƒÛ&€ä«y'6÷^µû:λ|ö;Ha2>ƒ\Å0.e. hžc&X¢péÒÇ@ÅØ ÒNxAœ×A#2±BZÃ|Nì^1”RÀä\ö ;‹È‡d‚ªs{|äÿsû9ë|è€|‡œ Ëd )y1ÁÛg‡?^¾þé?ì±»µï â?õå”(”ãX·Àv?…ÙItš,OÉ.0,B§®)Ÿø[+][ÔúòRïa{¥îµH“äžMÓ)°á˜Ó3D.X (ÙÚiùµ–“6§›™ ŽG“C6m:˜@‚è¸C˜0E‹/ç±ß0D¬$ +§éT#¢Å =&àvÔV,1_ˆÝ>å_¦ºÝI© ¯4 T8ï,öËÔ)‚lh&_1½’ñ„îÓ~˜Ž“$ÊFõð-Ú®‡õúÄ¥ôÃÞ Ê±;R^RÈK¢òR}˜E—Óú‹Ç—œŠµj€4¯bÌKH´ºÞ`wб#¢ ×eŒÂP_•îª¢Öu é¤J“ôìkõ´T‹Ž Ú[£BÖ1«²FX<0N§SÒ—¬A(2’®\+ÝoHì)û<4€ -¤E.ÇÆ{;Òë‡M*‚©“cU9 ã³öŸ²«ßp=þÆá¾®êhUÒ NîÚA#œ$„†{!F¡Þ05¼‚†4¤Dp^rHÚt4)«ÂÃDé¶V¦'ÆEÕˆf ßÏÞ¾íWâ’4ÔjÄðÄcÙþ|^úŽÀrrL†"ÜìÀÁ³õ]¤Ší"Í>t%pùÌãI´'òÐ{Ųò˜íTtš@DBMévžM¢É@sãÃÏðÜ ’ÕÑ®KóuAØwðý`BëСÊÕYjÅB#⣚TÒg®5J }…™vYÒ-¹#5œÈ~=i•* çE¹^ªÆžG?ä05Üôvmz¬À¾}6ˆú[˜¥XɬÖd¿6‹s÷Hò¦¯ëÕ+äÖ¨`®¦*éÂ+ËɹeU¨ßŸ‹×…a¿tÏ 9]ÉžG0LéÍö@Ò'oé‚.v‘G¥€ÌÊmëÕ –y”å¶ %ÁY4¦fzŸ>ÇïüÆ Jt³™‰…àØùÔä¸%CÖ©@9M±yŒóŒ1RÒÇ8ytƒ(çF –S÷ÄùfÃÈ·dö¬‹|ëWtVÜÅô&ð®Q´ÛHj&0'Þ!ÝçÀ:fÆ;óxŒV vj$'šòä“‚SþMÉüßûæÑ^™á÷®ò%S[Ï‚ÜïØ{¡4¬~¯‡?¿y÷òÿ>;|ùæ5Þ"E D”RÜ€üí¡] …›b=&eER eËëñ^¿á1Ð…ÒCoºäu2jr>d¿Ú˜@–â­ë°ˆ<­AÃiAümM ÆZeZë÷ݯÅg‚+Fk³-¨Û Õ;tש;v#¬W ÝÕMiͯ0µì“‰(Æåan=z/4΢P5«Aã¾=Y³#8ZŒm3Ô¹ëÎæñÔRúì#qBDZ¢XX´1y 3ô¸¨F€ÔûüCœLFé _úY˜œF_+ Ç æ!‡ty^˜@i}b›ŠBñ”öÞlÚUl¡å87²IÔ¯oË:ܱYR®g+H¶ÊZáqr({>Q3š¦4a|Àô´ç†C“ÝEH1ù9 ÝRÏgÍKëòÉÐñD†Š#ËXCקÚôüáÑ.íˆ]tã`”“zÙ±_»“þfZ³Vî5ÙBÍW*ngi]†T‰XÐœEòÑêÔ6;†µ¶â{57Æ6º7.Ñ,EPÍõ¨5¼+Î,î½v9=vÇ…`®$;òhŸè-Wžö^©‡áæ.¨¸Z‘ òU$pævŽÐáhrò±ÂˆÅš:åõXLeCÖê+ƒS?©Y‰÷U!;ÙQ°‡Êy˜Kƒ €eI0[ùÀšØµæÑVÛ{Œø8a}žnö7eq8ÿá#Íݹ `5Eï½ôéÏäËC¨ÁiTPÕÐj§†ÇCZú5*¤š«{•9-¦>³žB¯-WÇaK(ÎûjpB¼jD´‚ADëÚuHMÓEã\ñ-™u+]k>0j+PæåšXHã/«f–kS;*™O·l²Ãê¹æª(³ì* «MJZ ¶¶òE>³ç6K5Ôáß$󊜠Š´‡M\½'O¶ÿùê—­'ß‘Ùñ[ƒV¿·Û¢× df-,ˆÝúîéÖ€OI÷O˜ÐJ6wЦvÉ× ï½¼#>Ùá­¶žì°Oa45aXsµ©×m´M?¸íkõØãAÑBÉær½aR n’€0¤ŸëSþË“ñHz?àïâýèBûq‘¥¦¬Ðèò§‹6Aà¼ó%!—®éœ•lF$´™ô…„jöÀ|7(Þñßr7žïõ¹[×çÖ—}2zêÉ:{ð1ÄTl‡Ó©^Y ¦Ì¡CjR튭±ô²^ƽäåX¡ÌçBjR][9G¸³ n§ùË#Ä9T†=VHÏûDã?Ià铃Wô—ë–³¨€„É%9Cÿﻺý `ÿªKŒUmýšdÑ8=M€9ïJ:f+ÀA‚Ž°Pb²y–ŽYö±-²UdfnTn)Ò@øÇD^¤ã˜‰¶ki"LuºÆ•NNQ|µ;"7þvÿN‚v@;ƒ|^¡ìëÌd&³¹£¾·&Ž7æ2bþåú5}É´¤O6:C©ßÊÉJm›Î;ÛÝëîª÷ÿ49‰O—òà¦t€Šýww îÿƒÝ½Áýþ÷÷™YVÑäï«*´*+T.M¸—8ÎõèÞ¤ê_gý?ì?|¨éÿ@$ܯÿ;¾þ$ÌR±ìÑCt¢¬zøªj±C›ò5ÎÇ––¶©iqPR¬hè¹C˜p  iãÀóÁ®d ï‘㯤+àë_[ô! vwù÷NE¬'é^4Ùf;ëír³맇EŠÚJh1Z§ãF)¾‘!”hm{)jTI­zh4I˜U®ÝÕ×:iºZ[( Õ\ÐÅ‹FÚ‹±{˜û/`…AôLûQ²ˆ—÷ñ¥¾Ã¬þ€tst´¿Ûï^þ ø>&-Ì9é‡j@ç ôÕ%ý•†yi°2;4åŸÏHï‡PÂ^¯H cèá”_¦ËÌ‹'t"¾^ö^Mç®Vµ×ÛòŸ¾aùF¸LH\0½Nd@rX'“¢I4ñ»Î/µŽv×öçCÅQɵ .ÒóPÎÑØÈÂEm……:J‹|I£Lߨ9ø0™ éoIz®Ï;&ëœccœ»Á7õÙfe®©Å4vžºÓÿ®&šu‰¶žv÷V)p¹D…:TeÂ×n¸³„úý£_¼}÷â9fzoyz1¸ÇÉÀÙá`6ÿ1“hNz…=ïUzaæzü„ð]Ïïl­°)Ó*ZºVí†ön‡°€p¦ Z¡ì[oWìvÒÈëñÚJÝw¾ôóÛ,6{¬8ÿõÆùïñîãýûóß]?ÿÑ=|•ÛöeÕ15³¥±Ù…‰§À–À¿â-‚ú½qs-o´3¢°äfDUZF%eäÛæsl«÷¬Éf:À`(.‹q¶é‡÷‡Î´Z2¨I<-Õl`tÉ”ê¨}r¿|~ùàvåÿ^ÿ‘qÿßìÞËÿ»/ÿ‘YV’ÿøåÖ–Š9=é‘®·Ôã­vûØvhÁ† á!ÃûCšN£0y ô-›}òÙÛ—l¬ôZÀKÿééé4ͳ™½2`ñž—PcãVz:°‘Ë ŸÒ˼$ÐXÁ-ðéÿó'-¶2 *›J =qµ6Í­Œ0®[hF,»Øø,Zr!ÍÆïz<)Ÿ…åh”ýƒìAä :Ÿ§QšÅ§qN7EyßÅžˆù-¹{ó$È9üF´„d.§k#áJ,X™–¥=›0Zè«ä)d·ÃwCü‡¦ ÁF׫C®kɲKÁ¿VÃ&ÎÈ œéIlÄŠ; &6¼Ï?â BÉ‚g¼Ú*A}ï»UU*N,bÏ5Ñ)Ÿ’{ØZ2â^…ûÂô?"bˆ|1ц”ÀrýoÐß{¸§ûôÉ£{ýïŽë/‘YÞ¯¬ J_K«‰œeôŒDÉy—*^dkëB)ò n´ÔTÇ8‰˜MA6÷O¾×‹‰~ÏÎïúc¹k4 › +ÛI€™,ûL@ÝIë Á-¡41„¼`A=T”jŸ_V«‡dñÐÃÃ0¸††|ÐzÊé^ÛØÇúù\lh²™.ÃyÌ¿ZâS0&SjÅ[ 4»_ X0¤¶Ž´´h ©2_ ÑÎYŒ¶1[‚[ ~K¯˜~J— \»íïîc–è=¢eªÛ´¯ŽC{§#&¥1¸Ìû©ƒ=h4ô@Ùü5<*Á Ð]åÄWã‚Œ!ÜAÖå7 f]OɸQ…’_“ ¢µÀÙ¨ÀÑCQ½ÇÀÑz<¥íÛlÀOŸDÔ#ë\Y6箄ì—"S€4H·¸ò?æR“õ³hBä÷¸°bÔ¬E@Þœ¬]-² azowP±{¢¢¥­SžŽÚ–¢ÍavüEd°bbǯæo²¹ÍÂ$Jšã¤ë‰o•ëî*$õ› ©ÿydc+méüé¢ý·‡ÞÛ_½_üòâð…÷æ-Ü¿ï è©ô“Ð)í9ƒÝ]¨¶Hzñu» DKð½î}€¶(¼¯Òñþ”ì&®ØFŠÐöoÇU—S=%²éQîcmþ¬n)aNº“~ûæ½<ëMÌÙÇ>;­Ì¸b¾}·Àx]½FQû!bµ¿UKúZÆÙ`q Ær†T׆ ò(a2Ö­Z«nÏ2;È.“Ó˜[/>ñ–¸ q âk)Ù] µ‚s’¦#ÈPh‡H€nm¥ q×óßÓ/Á©¬øœŒÉ*EôüŽMÐÄû)þ˜,gœ:èŸVØA—&çƒxY Äj±X¨mèÐñZˆ³ƒ¿aš„’ì­ ®fä(ëObì÷8¶Œ0›¨³¦Ãtݺw‹ªðU£ò¢ëRPcW¹_!ÇíÝ;W©© T ¢iþv¼¥â(·†¬‡‰¨_5¦ŸkM-ãcwrÉÈ>,…C ßmN7RŒ¬I)%ºWïС‘Ô*7bÇËUÁî~mXýºßþF˜MŠ0¯d2Å@ê"®°¯†9ZTÍRÎx3¯FX˜ÒNb‚‚xÆj‰HN¢Esº­× ƒwH±‰¿²óè'ò<à¿?—¸¡£JßÛ¿yÇãÄÅwr1ͨlóS) bàêë~dmï‚5ÇÊCž M¹#ŒÂDÁXùµ‘L²”š;Ú¾{f¬D4×ãx/.;BÒ¯:òåX#Ö%A*vZ‘©ê÷{È°úê#ÕX½ù"‹ÂYåú­IT·lä^9ÏÉY$Ú~Nx+#:Gü`ÉßÝžn{Û¿DÉ)&*ëöœ³0ÉO¢lûKv‡yôhßÎÜBþ²Í¥é  qÒ¯ÆÔz%Ïižz¸&"¼;823ce8eÝ” Bpv4F gºMI_㘬2MqV}”¯0 €æ@å[e@1xáeÕàÄæ›Ììûv…ZWL_èŠ-/«Ð…ò¿‡ÙiŽ&eaϯl|Ðë-(õ¥£­3-š»'‹mš˜¬çdmɆ(00F,Ԉ߼Ñê‹øˆ,EöµA ²OžGYxf\¾ŽRÉúÔ ò*ϱF„äЈm×µ•K£g‡& wãR§Å }bh W³tüAÛÚ¥7„¾ÅÁR®%?¦m¹ ÍfÂ&­XMØ\:ö¡ìû{1k–÷*S@]tŸ ¬ÃZ}O«i׈~õ®û5ÊŠº¼ fÒ·~i6ýŽšÝ¶xa§¤AÇ~B✠ï5ýE®L,õd®Ú ÚAMhµ¡phvhe®YVÖ+Ó]U¶ëÛø®_ùÙÀöÙÀ­ ^=N¡ˆ¡Ä°y¹ò üzPP‡*ãöýZŸ ´Ï~3OˆHÆàX¸÷ò ‰uÏå5„+µb^û q8ÖÂЯp9³\Ö’Ô¼³ÐŒ›žnÜ|§nùD GÛ"+À É#ãMz~-ÿU ™Dãi˜I–l®†P®ˆˆvÔoêXÅ„Ï Æq_:•DÉüË»n_]w襻lðÝÒŽëº+D¼Â‘×éâ_Ñâ»sïz¶’ÿ×4==² g©ŠÿÚí?Òó<Þ»÷ÿºóþ_¿ ³4ÏB¿« þ¢­Êá ì¾ð”Áœ4I—è‘ŸØÒ…Ðw®„!–·…ð§/Y·ÆÁFgª†ÖÚitŒmíÛ«âÞ;÷þÇ)ÿ‹Â#ܪäÿÞC#þëáãûüOw^þµsVpÿ}¥—¸qnEËòÍ@gõ°ËÜ™ÿÕQbh帔¢¿®wÌÈ)Az„ÙiŸ¦×vl l Rã# [©¸å˜–¼AÀ–TI gâØ +Á* ¦Ÿð ì¨-Ãûm³ò££ÅfC€Ëå0<Öåÿ£ÁÃ{ù×åÿ[Á,+Èÿâc5ø#ÄTYiFÖù<&«=šF`ébb-ò‹øÁ&G£¨åí?Ã5l£ÿÞÒÊ;ð°ËhoíšE¦Ttíîr¾ÌÏFÜÞ1byÃLpmͼåàÚ>²ÀkkVƒ2¤6@eK>'GÈ,/FÌ[ž¥¿jÆè^wÞ2™BÂ5lÒ‹óQø]û%ì¨9 ­Øê4°†Pµã}Ç^ÌÓ¹¨ÑB Â|Gvp SÇûæïkx~Ä {ï #l>!Œ¼ˆ¤‚©/TE¨X26EH]UIQt%Çv€v\uºUÓ<æ£4©¹>¨ÍW¤þžÇµu L\Ç8Ñ^§ 57žóŒÌôŠ¥ß <ŸùäÉÁWØZé?a+â4K—óµÔÿd—!š8m:Å8iB„·‰0KÇ1$,£ë4ÍíÌ· « h t°x+–p;FÊ•L}ŒÆ µeØ÷eM'.mMFŽ™˜Ô4LÈÞ¿dc$k.M¶£qŽ5é%G0 Tñ•Þ(²®®MIÖecz¦‰ÙËR<(ÍÀ”}¡X_ûµ³ðêåãtnêÑDÐ…èši,>SF›v;ý‰|>–õÁcûp¾!èxw›ŽgÐp½x^GO討óG‘Š#žð/“Ete]È—,§eÏ/9¸5ž%œNâÉ°Kø­j8°À]ÎbE©#’¢Á`ã"iX’¹¯d—WaÖG|ÊRr:Ÿx¼A%æEû„ùÛGèl¹XBªR"‹Éɉ@s¢–4Ť¦¢ecÏQÀDªçjŒCÎÝÑ$ἜÄi [&«t(¦ña`ã­ÏÂUÈŠ>ÕŽÌ!MˆbwâDk— ¤e,©Ü†ÔA6‰Ÿp1šFPD¬AáÂÃvˆ2ÏÒ†¸!i£lG˜Ðe”T¡h:…¨ d )Ü‚”A6‰ÔhÊ7}ëîëÜù±Cç¶Ïûª EŸFi,yΓpa™wjÐऋ³òÞ À=;³'ô¥”{ªmU•iç²&ªÀP¶åÐs?Q\9•/«ÜQßf ™Ç¨ÙÀàpÄÖ-Ù ¥ánžCS ßÅ ÌàÚñ=3·xätëL,ÄÛ`xb™#!›ê‘JŽ®DžÿàþÌ×ÅŸ.ÚìH« \)+k`…:U`âç^L\ÌÒ—ë@¯9?ê4ÅŸUO7šÍ—¶F¶)Z׆k¢Ec1QílvŸ&êÎÛÿY\¸ˆÚÈ-@…ýÿ±‘ÿyÐß}üèÞþ×íÿ,AÛYá@ëÁ’4m"»TN+eyæòbÖóËDs`;·-;gÇ˨¢Û’FulµÚÌÊo®-ˆ´__i€6„¯%¾Õ–´6¶Ä"ØöòH4c mk÷{Z`©lçYÚÕ½ù–²q»¯:z×ã [«/ÈMyËjÇ)ž}c¦ËÝBÝ ÇHneNý€+t6Ë.àË(z`Ãß,î9Îé¿lõt6IU­²|Wd:ƒç?ñÇApõ#lÁ³”+áqárâ+øN}'¨/±Ìž’ýa-§1BÞõè‚eöžzÅÛŽsÖý°+µ¯Ââ¹Û‘¾½±ÉÓî­3§¯:öÃX.Ï™þ]{ž+[NôêÂÞô¹ÿïDp— <­/I_/5ñQÖÌãòó€î#ë3ˆ6Z® !ä­ C:fÄ.¢½(Iˆœ@Nµ9ÀCv¡„À¹ˆÇ¤ÿÓ0ÛÌR¸á™Òè’Òù–1‡5ëƲx`c}È@ ‚ ;LÛ±àDɵÃB›¯„€Üé÷6C 2¥S~ þ8ƒ:„²ÂFž””½³ÿ‰ˆ)Nñ.ðE lÚ)|´‰~ˆl”¬DM;8Ž“0»Ô@IÇ‹h±Í’HtVÜ,I •2 T·¥‚¥íÆvköK—È™ÓvkÏšÙÇËh6RG­›€0³+Ù8ýÙÒžf•…jàAFúîbÏÍt örÖõ‘âSØg“xÚ±µ$ìxðeyÔ4¢„Ö'@O‘P ˆd Gd„_p7“/–ÙÔC«õÓÚ¸¦ï‘]Ù߬†íPC°'Â;!OíòôÌ ¤ª‘úчÒêÀÛ~ 6†³h:M}ïËC~˜Œ„ëTzÒ~ ȯ‹}ªØ(Ç|xœf È•(ã–]?0C>ÍWØå¾dCx‚XrrrÖìí›þNz˜1mK³&vEf0š³Ä~eªP”­ð,23h–ÅXWSAeCó{îð_·ýãËÈïhoÕÒœ¶àlkeó+B³Ù,^öLã“.E!«'µåUÖ4-¢ª|cÒ|Å=ÝÐÜÕU”“_Ãl‚ØÝÝ؈׉¹$v=õJÉÎ 0U¥ùà³ÜK“饹¼ª€‡Y§d 4hCoLÀÈ)î"ÊʳFËèóaØ5é†xww´¦êE“"Á­õ‡è2Y/37­"¬°*÷õϵ$nDI»'Ëúd¹u®¡6«ã­@¦jÅlCtÒµ¸ÆT«PëŸßõ”pºåž¾.Œ÷ Uu?(Ñæ ¸_ÜÚÎäL4i‡gqŽýÅ«/6O‹ˆO8Æć÷^!wÇÿƒeJ¼Åú¯ƒÝ‡Fþ—Çý‡ý{ÿ;ïÿA™e¿úeµmWá=Q€Q7èßW^pìi-ŠŒá,¯¦Í—B/¹¥Énö%·šë”þð÷žÞ÷7a|f=v½#^œ«³Án‹ís™Ü^ g8·õjóâ^ün„ÿ]ÿv;‹Nâ%{$yëD3{M°¼Îãà9KÓňöÛeýwì©æ`dúOíÉÚcÉÆY."2[|-\[“2,ðsøõÝ/ î1 8‰™Ú¦@G»º®ƒ…DX1IH<üµl“­_Ø3Û «ßÃèp˜VEq c€¼ÚlÙò¨3aÖô&ç,k­isØë§I—­Ÿ‚e].òFî-ÎìŽW²ºÚ.ªqË°†óy¿^³AÍf½Ój{%ñؼìòçÓÐÈzk‹Á‚Y2Øž¢X™+òþ. D£AYø›DO^•®Åá vT}èp³^¥/™…ÊûÅ ÕìTœ#D—ˆ ,JxG [C[ye¤ÏF‡érÄלé™{ˆ3NÞ¾Fy"M5RäHÙ‹K>§ ’tR·=9Q-FE8SþuIEðY˜}€žÌ,J¶ ÛŽYZXÌ’½„Ée§ÌQå¡p“áK&ÛŽ Ù•“H8‡1¢Ya‘¯]Š®5«À9> “ÓH®hÉy¡7FypÝkB{fÕî—A—Fô~h²¤¾‘cxë8œ `]9nmóo:¬FçÓ6fÓõœOÉN£$Ê0UÈ8Í°¢"ÿšï~~íÅJSSiPxZÀ’Å®”…vÿ‡EÕ\@ ’4,¡ë»6V«ë« ]t°bâÈ"àºEò]†›O6«—Þ !úNä±ÈæVïC“R…È“4õë}H$áP‹¬÷¡¢g¡]DJu½‚p]õñÎ==²HÊqá^%]6î§Ç¤}ìÐõw‡ÓÈÔz ÍË)²:™To%‰Ê˜Ú‡R™]Ô™DJ›€%FiÔ4ûÛ<ÍotX©²ÆDŽ5g²¼Ù‰üZoË5§玛œÇÏ/žýXg"x[k&4éÑMÎ…V£­3 Ëzó±íVž««[gFüä¸ÞšúÛ7ºjž>ÿ¹ÖºHÖ›ŒØ¾Íj1dÓ•ÌDú+õF-ö® Šh(z Ñáî¿42µXÓ3•üE5_ÇW¯‹¾u½CĨ¤]iÿS5Së_‰W]OëÚ¶u‹Ú­hÒì]þMÔh2¢ðCⵕ7/ûjF¶Ô&4é”kƒ,#Ëå‚QýPô‘QüŠú—]ø‰rª˜'‚–Ó˽‹¨©g.Y>"k +q¦¤Âò-—×%rx~2cì©Cyá)Ä–T;ÛÑæxËrY”b¼¡?rñðjÞàÐ}ʪZXsKÖÚz¹Æ°îuyæG À¶Ï?qƒµåFa5í´{îì¨Ù7¿Ö.UÙ3,urŠÇO•„€Pir¥%÷VÂ0=–Lfºb¨µ;º¥Õ¬R˜($P†`êH…©gàdãìªJ­ÅŠÍo–Nâ“K¯Ðõí)øêh$ÕÀ*xKMƒ"/kîÕ¿#d÷¿îîHÙšhΡ5çŸf#G#w¥ 7 ùZ¬ÚÍÀ6Z×ç_Cß Ûm§În½/3wšÐsÙÂ,£t±UOhÆú–™5dÿ¢‡ò%Pc$Ë2pøA@fxA,Ó(<‡y3ÿA1Jþ;AªåÊh­¤ÝË$Õ²²¡xYK^BÅ-3Šç rSRÐoWvÊ#×–£Ò7µd©ÈóÍ?=c-³ ê¯àúߤ0U ³­ýNvôrc`3ãUÎ}4èlœÑ`#¢©öìëŽÕT²Ô^€›‘.¶eWGÒ˜+o%-_ß²¬ãÖ×Øøõt6h}KRF‚lecíCðüïk¸1%cSã•Í¼®„© ŒÜñp3jP],Ü”¬©¹ü6$iŒEWK£ÑÖ]ƒZ-óx„Vâ[= ŠQ+$‹ÝêF¨†]‹šÆôÜ4tÍ°þôt6Çí6Šô‘ƒ31MYPÏADž¨肬éWŽÀ-}@®$Mzzq¼ž¤^WV¿2ï æˆžj¶¤h—í½ãt6ŸF½|%a§Á Ö-÷."#=dzüoˆ¹sÜ¡¨ uî•4ÔÆÓù%i®Ö…Áœoöä7Zw•$ÀFÕ;4³º‘Ôù^ÚI ùЀO;³ÝÌÐh 2EL:…Ö•œÓ °¡½ÊÖË‘ÔËPŸžF¸:4Ô£ÁÀEƒA3  $ 6HƒÁº4¬@ƒNƒ½:4Ø«Gƒ= öšÑ`Ï ÁžDƒ½ Ò`o]ì­@ƒ½¡!‹é|4Î#q-ÄçH“ Ä.&2UuW{ή6¶Ô÷Ø¢dòqxŸÕç ôÿ‘|/6çTîÿ³»÷øá®Vÿ _ßûÿÜqÿŸ̲‚ ôu¥ƒÔÖæã£ÂJkžÓŨ2¼¿ÄB@N[jéà®wäÓ,Aú=H°¬ðuaµës)XºëIž?M§RÀmiŸíç%zgŧåfY®òªP¤9¬á2í°ªÔ³íüëæ,°,}ÝdЕ'Ú|~“tŒùŽÈZë>RLþ`Xë&Xø>#($R·k€#ýU„¾÷7©²d+Y[xŒ½Åï NŽú™3!’’P ©37Þ"0l£= óPV¥¯`ÕD¯¼“0žzèó ~ùZâkï87Ì"ž÷ZIP‰’®¨ã^[ÚšŸ¶N–Ó)Zˆ¨úøñ£?TbKÂE@'#P8jíÕÔ>B` µšS`ØY‰;y·EÞGÿÞõúžé’þ'ò4l4ùc•þ×ßݼ?Ðü¿=ìßëŸQÿkXKdB׊- £”f‹*^àÐÎç[Ò¢ÞkS’TŒ #±XŠTk¸ÒG—Û¶Áõ•«x,–ªEçqhÈÀ"™q{ÄYÓ:&i:/Ò— ù’ ØžêEþ wg9·×¶¥…„²žE'Q©qzëïɹ‰7:‚MZ¥çd»ˆ'–q‘¡©ƒ3sÛßñðñ2ÚçK(üw½¥mQ41›oÖ®€ph܉ÄbÙ”!ê‹c«÷¢¡R‘55 –Øèÿ‹-FÚ`¤*^áR@”PKND»©ÁkRzÿFh)£na5È#mˆárqFSM‘í °Rèù2®¶Œ]èË#åf‡7§!gbüØÉ"¹ÄI¼À’t…¤†[„P×âA2”í¤pB¸4åóÜ(`Ö‚Ñg(m<¿.âi¼,ÌÄïyKtÑõ®*ÊÑÑTUuëhlz`¦×Ò0’V¢0Ÿ‘ðl"W8Ç (T Ùù©Sñ¹·$Ôǘh2‹Tõ†ýÞEšM'=¾-È<¥rVî‘Þüp‹”n¾8¦}ˆ Ǧ'F:3+;hÅó˜ìQþ )š^¢ FLe««û‹~!ëqèƈNÈ&‘*êÛ$…1ÜjÌ.{|eŒÓ™Òƪ÷å9;žA®ˆÇ׌ýegB±n™ýeŸÎ—ôLôòr‰î3‡<ÔQºUK2}w›­ôa/ŸOãE»õ[Òêôò4ãù©wTˆþ½«¿Ù? àþÀý ‚+µ1IzçAj–µðV!äú–Ñè@¥Ð·H–ƒo%8–†¦ª€Êòq–^€! Ïâ4 Ž,Oçz“ᜆIf¬lð×C㸫}N3éP¡ñüÍ›ÿzù‚ŠAÞà`–ͧK2ÑœÀzœ~<`[Xí=Ÿ~ïws†~cb°·œO Ë´†ØUÑÆ& +æ •-ïÈòÀò€~ Þ½¿V£‘×þÚ$€_ Сë+]ð5dEÌ Ûe{G;ÜY¯C™£v,Ê5Ïf1fJƒ¤tjÊ l9#ÜÕ©Óö˜F¤ò'å:gD#Oa»Œ¥7ü{–—¾Þ²¹ß’l´öŒ.:ÓnÁQ)Ñ¡úßs㣃A}Ëž 10ÞÏP‚ © ž…sD\{Ó®>iØ„ÂøËßÃ,诘%~T|ãùg‹Å<ØÙ!{r8=#ÊGDÑFt{DÿîQÚÐ?$é5T‘ÀI’“#‰8ŠðÉÿé¢Í±ç™Èí|@à=e~|QK­¤Ëh‘rD¿/–õP ´¢€ÉwÕÖä¯8‹&ß11(oñ†÷‰¹Zrš§M+crNW(2²l¬µŽÚ뮣ÎýBú.$šs–5ÞQ6Âלí”Âýs*ÏíÌ—AZuìb3÷ùpå1+49ÛD¹L¥õQ¼ ÔÈ&]n|"« l³¿}Ë4?A×[\ÎɹxZ‹£-OÒe¶8«¸¶ß2X\¤›S1‰4ù®`Ç"in1$/2Âñ œñãŠ5–Ï=æ×s·‚>0OÀ:Šˆfä¨2/ÖMêU*ëºg8þ·‚ëá¢mx€ÿø[›;æ!,…þ`·)ºO†üÃ?]´é<ä%O¾Î9óˆqkŠ_ë+M:Lˆ.¹©³BwG”} ˜úë\7|K‹O¡Ôø,žN,‰«\7äéŒlAä#h©m1˜CCf_S É 8«ö%9µŸF™õ–ó|òv¢³õ¯½Ô% ´„ÈJ½Óh¡w©{ÛóHF¶µ·Zvà>©~X: UÓ;#»×¥c‚“ð2/!»ãºÙ™ ê•%R½Ür¼vã¢âV)?K—„§ù–ËñÆj,ÅÂîC °fl£ø,¼Óìù<—Ý FYHþ[Å åáWÙÈô0ºàœ»tQK¾f)æárüŽ@ ¬˜Õ÷ˆç[ÓYz1¹–ø¼‡-ª¼ß/ Íä5¤Kj‹%oYuͼ ìØ$¬ Ç“2¸ ‡Õ¸?ð­~hÑ|z &èó([¸m÷ªÚ®FÐ>‡™¿$Ì4Ž—C‡µŒ7ûŽÿr„­~ßç¼þ¼XûŽÃ¦Ž‹¢ªcæHÏË jtF¸hY¤{Y^RH­Šˆ!0fê •²Á<ÊÈŠaŸdÕ«¯<ùuàíôþ¼ã]wlºÂ‘ÒÓ°Ìœ Ò‡œ"¿—=­Ëm¹ 2mŸw´1,mzó隣@«;£ zðËJ2§dÌÚ”@™¼$ËÙq”U“… %6Ò®G?%ïŽv·ÿÏ°&Õ¼'OÄ ÚASBRÀûkbºoTŒýC¬æE–’í«ÖhêQiwßÅ-Ð[1 aÄH°éhç³x2™F«LÀ ‰&…nà$â@0÷±òÚêàv“Ur`x<.¸Ï»Ö•_›°éèªD‰%W£'©BöLHµ•Ð­\<ÞµåÁ’%jÎe…%f;QèÛ•wI ­¹=ð¹"Ù‘¬V1]gaë»Óî´Ø9Cd†ÀÑ¥…Zð·åy ¦°Xa1×Ì&›ßQ6‘œÒÈýÊ´ªêJ ‰rÁ2?PIÑFIѱí]ÌlÌ¢ÿFГoßh jaèp7f}-×ìJÛ”…Â'˜dLÍü®·Mð€Ã°ä@ôCz||éöüf†ïš9X×öÏéÔÈZŸ/.ëÌoi™žïo|.À)þùê—U(á?ä?åøy‚Á0O«áÿ8›nÿ ¦±¼»³°Ûpéãcns À‘ÖXˆÚÚOgñb!ŽÚzŽ´Ò›b¾ Y%ía#±a¾dÕnfÁ:Ãïë'a)1¸ÑÏ&ìøÄ=¢ ¼}¾œÏÓ ˆò;Ylƒ•×¯eY~PÄÓoGð-mÒõZ:Z[d³Z­nj1ÔÚ¾äê¸j!»¶‚ÖáYÄ#Ú5l{¿éÐüæc_ åôéµ®‡}Öèy¶pLÇüÂz¥„5¸û[o|jââ`¹8Ùþ«¿e_ÖÖ}w.ÂÒµh®>ø”pPUÐP/§i8ñÉq´Ù­±*Á˜ºÈÒ€]D%_.9‘g†ÁIË"JÙGÄÁ@Ÿ¥P¨P÷d…ÈqbÉŠP´ùœñÜ!¬ðâjª’œU ßÒNMôœq«1\qöòwÌ;¤Æ·=²)±òÇ`Òö¾¼±ÎÚ*¦ùd>h܆tžGÞY|zFCáÀs%‘”v«EoZ®¼xxûa¨ÍH¡bÍülˆ‚¡gMϹ•ÁÖÄׯï~±¡‹žçÈ0ßÅ“»¿aüjÜDÿUAqTûR.-Âñ8šc=b²vóð4ªWÁt9ÿÂÙ–‡Ù©{RúþR}Ñ8‹º‹?l’,ÊžåR¡Àä¬hŽ„_HÛ—f’©‡îYýÍÌu¿IB'Š²i&PÛÂð iCFÚ%ÃÀ£"ÞyÐ[ÜÓ®È9b9a©‚2ÜÒ {,ô:‚ÉÝÕPÞ¢»`LõK%ùI–þ'âÙÀÌ{'Yý'ºë.Àk¦“øÒ¢’¬E÷.dõz¾Ì錾C'Kÿ6±!eþb€™dhÌD&pÌe‰Ý0ᨬD;MshÉ"Çß©õÃÊqhû²7Þ<’¹ä8.L»6–,šÄ™¼vèÙ•>D›Hè-³)U‰f÷võÅ,ï &º‚ V¿÷üÂ/Ž‹-W†¡b²P8WA4íqD„Í,='GÉE4#GÄ0‹§—€%ÒqÏ·‡àÊü¸·»æ×t_;ÅTE4ãtú’xý^ßæÄÌ6Ä3O^]*YþñâÝû—o^S„';0jRìÝ )ž%^q: ¤($!˜Âû|ˆ`[¸HÀÎòpY4 8Ë<߉»E_-³Áª\Ýÿü\-&VÊÕ˜9çæ,áQ'°„'~´:–¡æÆDm—+âY™¾Ö›‘ŠWØTá²/ι½ iqxÂB§F>^¶*“èBž’ˆ7'vÍUŒ­Gø ëÁ{2ÑðxlËØ븑ã7붞&ÑIÝž iGE«î°qB˜N^çDÒ{Tîµ£ }Ñü€ ¼Ð¼ã’ƒ&Tà›– ü÷ü‰÷éÓÛ“JA ÎK˜ÕÜÝÕ8¿ÆºV',³›Ë´n/—©Žn¶šÈ§Óxƒx‚lá„Ú³³OäÔµúœE&ÖFÁU ÑšUN£$Ê :Ô¦I´U5ò…äžÈ¥ ‹9ä1“Pó,ÆãᄇºˆD'Ò¥.°åzLB»·a_ò(e0(È·vPûÊ_¡-”0‡½7H¶¤I”¯qfÙÖƒí ?? ³ƒ»áŸåN6ŸMuS!­àA^8Œ‚ðIýø:šXª¥B‡TÌGþyŸP78ïaÆYÞh¡¶¬e+øíÚÊK¼û·ë-iº‚¬ã(b Å†•Í9­è£Uÿ„Ò²`Jë¬SR%GB΢“ø£…êãL»+öÞT±¿)Î!}íœ÷×f ©›NÉáS­ªVôÀ{ýæðE€ž¤û^̲QLÖÙ%Sj=Ï9¨¶æcÒ#“B±1Zôjáš‚Ó%ì˜L@–ùéY˜–»ZÏÖëR#n^Ó[\³°aÆc˜„8uP³à%f‚‰T@@h#Ÿù³çÏ_¼=4Ï“IÍ¥wÞÿKã›ëG ‡ `ÿ=´sê‘…ãÛÔ“a£³ù–‹Fé%•‰™\zLŽƒÙeRZ2Õ‰Êy?‘ÿ¼_ãá,Ê°xãhôÓË_^ŒF¥vŽ| —vpy _2PÌ'` m¥ÐöÊ #¿h nÇj–ÎÛp\¨®>fzlÒ¥wä?#¼‘çÛà?š¥Óíg Æn¿ÉâSrªFCåŸý•²âIEÞ£Ï]Ynpe KκT5W‹Y–µ.£b£Ë„X´ÊU`¬÷ëÓÑ'rFÓZW­¥²ÿÏ¥ò¤sf©<_Ÿxo§ä{–N'–¢».b9ª~Éu¹|¾þΩhOÎÈãgãE|½§·æAð:]Ä'LÜä=Ñ²Í ÈwP ús˜æE½>9Æ–õ/  ìÁ)¨ÍEL¯Dˆ®à@J3³ˆí¿ƒ+œ÷¤ Š­÷eâ¥8Úaª9äg:Ã"§xsÙ†ìé^Qu†2R)1Ä ë‡„q2":Ãx1½,2æƒïë¨È…Ö3FPˆFÙ2áVŸ¨;~€W´Qœµ\«*ÞÖþapÀXãt:%s$4±©‘u&f&#~— ÁUPgs`PqÆ Ï’ðe#óhx3˜‘÷H2d„á=qz˜ÿG#ÝÓÄA“¦ˆùl‰’sÒ¿*ê ß"Vauì*lG¹ˆð”ë¬O¬Öw_¶¿ `Û鬽¡ÜIŒuï·Äû-ñ~K¼ßïibÛ-U½á¿ðÿ¯J r„ßÈf/.G𤗵¹ŸÝþîî£ýý¯véöï ÿhoï«þà1ù½?Ø HûGƒþï¼Ý¯nágI¤nF@¹8‹¢iI»ª÷úä¾f ò| ûˆºèú[â)rƈr9 _3±Và=,3ãY\ϧažãIž5{öö%«.¿á|.»±Ú3j¾KJPyËE& 0®&©¸ã0Ïd”™`ÅØ]‰¥ùÕÅ᧙CuGË9Í:…7 ¼_[*cùšÍD öšNaÚYº<=ã÷f"¥“7üJÒý†×)]è3°Lxo˜ƒDtÁ^ãy[j„ Aà-é§dCGg«)¥±ºxÕÈ°ÔAœšòr È=Ý–0û¦íD¯Ì¡ðÈQrÞ´\âC߆d —‹tFè{ã%„…äÞÁØB=áå‘ :€; Ùz&ÑTFÑMéw{-Èt¿–ˆ%`”? àÆêr24§CÑë)¡Í 9EŽC¸øNiús’bƒ Ï¤-â8Â\ |'ùC‘ïH¥ßð¶(â(È1ÚjÒ¶(êˆXcTDÿpªJ[tîºdÀ‰RR¼\Ó±«è’6†žâ‘JY²SS È"Œî= ÜÌÂÖ¾èýä»hœf“ xMéŽ 34àzIM°Tþ¿Sï—Qv¹*þ2Þ»¹keC‹@îEDíLAkeë¥2l1‰Û›ªr*`oÊD›’´ÅÚT8±ØüŠ ¡£ÙêrÔ†z|w#ûV#‘Ç9X'…tf5Q8™ F—ü|ˆ.ù¡:].ÀÇÜ}Š^ÛšpåG}H^ÿÜ yŽ¢Ž­a別 ò(Û'öAÁ5ÉÙ•Æɾ®l^,Ëåƒ+ÚBõp­+ÎxË’Åg³ƒD ¾6SÑ’L9Í!aødË•ðŽþã(ƒk#9äÉ°ê`eè!„ãÊïàøW\ݵãIG3ý~C`K\7-x±6ƈ¶~ǺÏÙ£ƒ ”­V[·<Ë&¤\µâI+è__;¢4]Œ")}_Ïäw—i8„ UŒCt†öâ_4f¯üVø+oGœÃºô—ÁõðºhýzøÓö_[ß=ÝzûçSÒ÷6ŧ8ÎÀÔS OOvð 4Ü-ŸìЯa¼ æF'ö;ÁÝ]~ÏÞwˆ½‘7eÎ.öt˜r+hISn][óšì8÷–‹xc]ßwáøC@Èû[_ÎYÃî!büc²øXñ¹¥ABøG ì\„™pÇi€­Û_äñŠát®=“0›ÐªELHâ¡€PµŒiè+¸ûgºú4œOB¢×J™ývTø`ÓG<}o¥SÔöiri>ûë/~­nb±ÚVëw`Ç<&t= ‡¦y:­Û_½áyäóEÍ5ÌCë| v»z=w|w‚qÄ(®édƒ'ÝPìÅ‘QÑ®´1 ++2ÅÑR‘ AÑ€»½„}Ò ü+3>—¼àï£Ý@®‡Öøc“>53¼—wEn“yxu½¾íN²ë±¬§­õ€¶”œ)jX“Xî9»?ÇÄ××—ý¬Qàù­¤FcçØãk£íÀÞv 'n¸¶eü¶-D¾”mp'G¨vÜÚÐìÿ…¹üàú~ ax"Í–¯åVîÿµû¨ÿhWõÿ íîÝû}>ÿ/ÓÑKðFüCx€b&9YXäò˜ÇTòV/£ÞC*%ïŒè@rÝj±²à8£{°JŽ¢Bë]R¬7Ïg™ñ½‹0ǼtäÏh‚9ÞwW <ŽJ"ðX"Nh£Æ>Ãn—žøîœn…›œì(ç¬3«T‰ÑŽ€…aw7D9döÇ žnEW×w –$ML°Ó¬£TünX¦ ò¢Öÿ2— ®AÈÅ%3fý"¨OCH•Ä*Žtšvî6Pý¡úí#_1~ÿ¡7 R‚ˆj¬¡ð¥lÔÞÿ¬yþg™•F4%шZ)W¶TÄí?<ÖÎÿ{{û÷ñ_wõüÿ’2Ç3䟩–F€Á^4â7'#põCZ®Í³¥ÿÃÝŒÕ+‹ vwÍüóur8ÉùåäÎ1K ¯SL3tU `Ê8¡EêQ–Ι³ìh%“‡­ü$&›GHwt°Œc Äfóçy/kÀDFÜ®¿>äýsû9ýæ6±tMU0Ê¥»è×ìfã8q‡9ƒb覈¬ÅÒM«ÖDÇ£ºè Ç˜;‰‰ü,½ÐŽYü̦jMŽU~F´Ÿ ÉÉŽ‰jhžAZ”ðF€EÂÂÿóÊ2Ò_ОßeÊrÀ¯NKsZ­Œ+»^tġ¥©»nç‹!1¼G<ÐÓÊcLÁÏ°úÅR’—J1 _yÐuÙÒ‰û”x1¢©åFÇÆøO㑹‹Ô˜“|+)ééþ÷V~ˆ\E‡ù@¶V÷þI$%Á•&•s`‡±§Ñ¢ à—ê1óö“‘HݦUIɪ,‚SÔz´”RÎë O£_÷ú E–H¸Ç^+ñ0Åæªô’þ‰P\°ê¨RŠøéüâÊ×?ÛÈú§é:V•ë_¯ÿ2Øï?Þ½_ÿ_Úúÿç–7s–ŽvCRÀçåoSüš|HÒ‹˜ÀÒ?)t݈èõ¢/]Ø×?‹åÍâY„ák7ºÿ?<4ó î×ÿÿyE™ãáCˆÿÜÜ2'ÿI!À7¸Î=Ÿ±¸,ŽÕÔp… *ÈÈyº\H‡¥`hÁ1r2ñ.ÉYÛQcÆÖ ®zpz­õ$Oùú_g×o°ÿ÷ ý¿ß¿_ÿ_ÎþÏ$¦·ý`.ÎnsËÿWºôf„!X÷¥‡ð¢V½ß“Þ_¾þ—T÷aë?_ST­ÿýÇôõ¿·÷è~ý1럩ÊoXñ· €£ ìzÁñð6ec}¾èï÷¸êë®Vì7½aûß®±þ î÷ÿ/nýÿƒs˧‹Q×ÿ@ð~àQ ~—rÀ¾þ‹"ß·ÿs°ŸÿónÿÅÓ4_dËñb¥Œ ¸È%NâË2ëþ”¦?„˜6ˆ™šéšþ WÞ›y”¼GPP,Ðv¹MQ-RÞ-z¤·ø4áíD=h(«HKš¢ß¦ó¾Y¶c(ÓÝB—¦fYÀh…jeF«|oˆ®g ¨ãòhs)B¾—ϧñ¢íwýNoÎÛß„£ãy§HwƒC’ÍJc²˜t3o|ÚË £ñ¬}ÖRÁ«´-ž,§SÞinâÍA?:nuÔŒú0óÒ¥©.?F—6x@Nº˜¯{uÄìì š„®/C®8XdÔ7™d4vz bRû4#Ôèõh¹IŠe(kFÇñàc‹ ¡¯$$2ÓB ­Ìx1½l´Ê¹Ðº4‡x½ôhZ®Í~Ju]ŠÌs˜‰Êö%äÄtê4S¤[@YÖh:QªåV—¥}WëíŠk+àëv„Þ«Y™E19K¨üø"N"Ëã/ãq$щ8J“h”žÐ¾ºôÛ®ÚÖ夤ö º+i½_¤Ù‡ükß]'FN`ä,šã=´yô¨#|Fä7}\¿.žQ—ò×÷0å{Yû£-)Û>PwÇ?]´Ñ €êÞ_~!ÚH£#?$Ål¹XbU`¢mN—y|Ndû`عÏx÷ôÿ5mÿuÎÿ{õû¿þàÞþgïÿ )Nåì*à’šÓ‚ÐL:ãbÕTeTÔÔÒ„¶àsmÁ';Öc^–¢ýn™,âYô‚ê‹þ[cè÷Û{aRgýÇD÷ ¿áý"™´ONâitÃ÷ýGæù·ß¿_ÿwaýÓrfï'°<ŸêAØd„o<Ê.‹,"Z/ÕÈJj«j„š«PŠÂm|$ö¢k‚‚$;ÃÃÀ—8³æKƒh…v"_þöâP„=Pçߎ޿xýãO/y!E:üsžN·ßE“üÀoÀeø—Ñ«goß¾|ý7úÍ$²œîsçœÈ¢ƒrTž†ãh²ãoæƒ(9'pÑé¿Jǘ+<ܶ¿Cô=6Çij’µI“Žyz­ Adckº<žFÚû®·HGpå°CAîxUj‹|ÂÝ£Š¹­â€³ÏQ¨j ²eB$(7Ð^b©XyÞ–)1çÏÍNk$%­1µÛزJåÿúª_-ùÿظÿÙíïßÛïŒü/Ô<CŽoót¾œ†‹(çúžùCï0šÍa©‰t“ùrA–õüüly|çg> ±:¹t¯µ]X÷–#_‰‰»bÐ>D—yÀþèÁr7qö.~C¨{Y¼ˆÚWdÛ'"±?Øó½?{ýÝ!0*£J7úM‘S0ïÆÜvX³€þSœ•ÅvôöÍûC) ¯AÌݵ˜E“ý„ïÀÉ”hÜÞ»_ø×èí/Ïzóî•wpàùPu²ˆê›…ÿM{'ðÏ‹PбÈħQ˜ ƒkO\ šâ¢0ýæÓ§o×{€ÁÌÞ“¯ß{ØÕ-¸ÿ mÌÜn‹.ÀuÏGæ„O÷ ­ß{Ôëó‚1ŸO Aöž’1¼o¾ñÚm„¦öþ¦#·{¨ÉÞ’¿u,ÕëM[‰² †h.éÄY¾èù÷±„Ϙå{„–Ç6­âÀ¥~¾õl)'§i®>!3Š“Ý%$ù?MC@ëÆÄ~mù¿ÿp Êÿþ£½þ½ü¿Kçˆù,.õþç£p ‘\!¯ÁžÏ‰âëi¢„-Ko©*¼åwgY¤…;Óƒ€ÞŸy,Ú½ëíì•^­VzÄÁ8ÇI4Qððw‚˜gó˜ˆDŽ¢:èáa—Áy¿$f¥7Ø»+¶… ÏÒe²àc›àjǵç p §<:°Z6^:¼Ò-œ}|ÛÕWqEQ\P°—1ÝŽÆK¼{ òS„ßb™š Õ݃Oq7B/Ôt úyÜKÒ‹­ÂˆŽ€õwÒ9r°ÑmÖ—¬Qmþ¡·Í{c™ù½'ÞÃß½ñH’ÿEYõˆßÛälUòïa_×ÿ=Ú¿—ÿwÀÿxàѾeCx%˜…HÂ-Að8ØìCÓ6qâ1¬òéŒèÀ³Ëþêã!Ô^]3Ï/ÒlòI­Ž*}¿ÓÊáâ™ãzMÊŒ ÜÑýøæõ‹Ò• z†êÖc<Å'Þi|1g2oLôÒÂx`€¢ ÿzøó›w/ÿï³Ã—o^£Þ~zÅÔ¾jûᄨ«pÉLél5­J_] 1ÒQçî&99ìíïöájû"K‰6 Á_8ᛘ$S’¸{Ûÿ:ò’O7s¨ÿ{ƒ}Cþ?Ü»—ÿwIÿ7ÅýïQ¥}©{ ªÌÇÓtü܇¶Ÿ¶É?×…Ë_-DíÍŶp% (!ÑÁñ!"³0ºCþ˜ÀÃù#¾yÀQå“7h$AD¤è gŸ}PXá ߬,¥Q"9•rx¬ª%ØâÄÒ®´²-uzà^Ó.Ý>»ž@Ä–æ_‚ãÊ wù„ù'G>vÒŠ7ô yõMñ P8´ûÂ`\ŒY]‰®ÀüATðÙrºˆçLA¿AÄÜ@§½Y”FmÎAùrO(Çun™xôñwŽ[uͩψsöÓKñ÷QLÎZIºÑ^Õ©KmÊœ({…þØh¹ Øõs•õbéD–;8RW–_5fGi»úôè÷¶ù ùJžÑßobÒœ7e©múÞì.éùü@Oãè†ã?÷w>6â¿÷îý¿>§þ·Šà½à*†„3ó(]ŸÉ •ê¬ rìtD-\!âöx¢Ç㼸ܢ×Z?,ãé$Êð.LÇ…Uà¸Î$ ÑILmV¥87ü·#õ•-€~—@ú£d;„sî‘ÿs4¦•–E=8”né&¦F¥ž¬O š¸ýXíyß ¤‘iñ®kÅÆqqF¨qÔlàÜ·¨y LÆØ›1i44j¸1Zn«Ø ô²­¢9êÍx€éþêLJê:z÷žôLn‰Ð#ë*N"p]Ï@/ON¥û¼|ÄŽÁ [S,íƒÖ ð›o¤­é‘ÿßÿýßÛÏ$fñ‡ÞÁÿçíü¿ øÒÏéÅi4›/.¿s-‘Y:Y’F!h`ö<$>½Cè‰tk%”¡®`ëgóXV„¸ö*Lp õIñ)ðOÒ”^Ň™ï]ñfCåiKÍÌ»ÐsPzÞÑ•w]’A/Ó%釰ïžÁðïÿ¿‡WTÙª"+ù±WY&1,¦&Jën¥ëd!§±´°8¯p,zXKàÕsóbe$L˜”ü]J¢u`«#°8h<³i5pU—¸1ÄÝkã0ýcW5ôÿ~_ÏÿÖüxpŸÿå®ÚÍ‹¾+W34OÃäÈìHÂà+=CsðHU›ýŸc¡2{×Ô„¬&bàýWÍAb‚5a7sqrÚ£ŽÒD÷¾° 'Ëy§&“ †Ô«®³&˜·ÄŽ!qyšiA-…Y„̉ÉÐb’j§`0-‚¶)ÁÕ%ú—]]AxV]•^” „Ï)ˆ2§Ë샇S꺫Žd˹”’3ºÄæžäƒêq Âs@³*‡¸[v^%ž-H€¾¤j¾Ì^oåÙRï#hè`M<"°©šÅ¤#Á÷¼9ØK¿z?Rz&—£8!;W2†øà¶CüªœÂ:ø4ûTtþä‰7“|¡k2°²‰•ƒ B~–^…–i ©_uÍH˜ äà§É2w~ôA¿²”ÉvžàSå @› Ö>b‚,Bj´zÇßZsA¸¬Ø\Å\’qî{†É Ô¬EceÓ݇cfx< aam<* áÈoà| PÏŠ“¼ }Û€-`½‘d'–#6#Ç`Ôµr½áh8 V}ø]’s<î¸éœL*kÔ —úM’…ÓëzHIJÇÎ=õnˆzæ†ÄB)”Ýgn»ù" à5eÀ›•å#¢Î ÆÞSK•ft'àNq ¹óªð6÷¥It.§ ™˜e ’ljܪöâc8›O£ÿ†Àê'.q$ÙµÀÅá)DÏë+2^ò,_XÈﺖ¶Ds]Ôl O'ƒ„R>-ˆ83ÑÎ&)l&" 0@³Èb¨7¥ÁÀá³ôœ¼¬QW ­ûnå*ð圪­FtšØÊ0¥6#:œê31éx; VÇíè•'ßn*EÛ%(î^ž¡~e¯.#_ˆ§Í­£êuœò$ZÁER…TE5Fvó£_ûü+ Ï*¯{$Õ# R™!̨í®ÔnÇâK4, 5;.¿ˆÐ; .¾+âeáM”A° ÉÚu‰4YNeñûå|žf ÀùdžÆÉâ§ðƒØýÊ×'$_×:ûJÀ’]èLÒ½$Õôgò¦D,U1s]&âÝŠž$ñIà‰O'Ñ‚Ì$(JÒ]Ä"Ñýk.ô_· Ê #C$Uîwš!ŠÉþ¯%,=C•÷Ç(‰!×à "JûbMP°= ÷J¸ðÆDT¤3ƒmžãcº(žØ2› ã•v‘>\o HØÚ‡½°ÐT a4‘²¥ûuOxÐɨQ&€ãÇ–vÁ¾ Sæ¹Ó/¹–$ô„ïá$ùžnö|"ŸLd‘#ÑB=£H—ÏLߨÌ/K’S‰dÙÏ Ðœ Ž=Ù2Röø±¡üÀPkµñVu²+WòÊÔæ™]Á¯«·IÕÔÏÊ“ÊïCÖ#”ys0OÉnÁoX¾4ðá>9‰2¢¹‹3–tø¸+Ø늣—Vd–w ¥¬F“kqBK$P3ÏÝÁ#…'Ð!Þô²½j!ZZA pëÚ¯ÏBóú= ÕÔ+zdà®Û¢úy ê«]åÖÜóÈÇ®Æ]ƒ$C%‘®…š«-pßm‚ñDf_ÞBøâQû[gÓ»K/Üm-ƒÖ“ï,UáÁo­~o÷·–(,IüzøÓö_k}÷ô·ä âüâyO˜üiôd‡ÿIíðV­UÔMœæ ieÐôT]?OvØclB[3"ñO%éëreX¬Õ€Q‚eýe^èÒìÀO©¦|^FÒðíúìF'R÷3zù/fM´ó«š_z e7 gÇ“ch…gþú‹,Ãïìf…ü%çŸj÷×0tŒ@a*"ç÷8ò-j÷§çŠuÿ\ßžRè3þ÷ÎÞÿýÄ™£F°h‹¾í"˜E¾]­ +%””<ÍÌ;߃ԂšfÂŽ¡nü<Ê,A°‡LÓôC`¶'}B~#4f:ã¥'>’ˆÄPÞDpˆðÃã1…aøBuá¬ÛïÏJìŠÿöÙáÏ£—¯zÃêIoÏDú"-Íóç/Þ: ƒp¡N»ïa‘Û+È–ÄÅü1—ê¯ yãßÉ7½Ér6oO‹~Jå‹õ(YæMá…|\Ä`°ìðD£ÆñM<!)†òÓždŒÈž¢–‹>ñØ8’’Öú­E¨ø[«Uîw½YD‚÷HˆÑ«eXô²–_oñ òò_²ÀLSmrí_…ƒêX)Õ+ÆÉ”¥13Œà¨Õzõ[ ºÿ­]1ðï~kAß·„ìódB¬ø/~…àˆþ F «‡TÈ+ |µÎn=LËg}ÏóŸwžúÁgÀÜ(3è:¶ÂåBVR/¯3"›§rHcQl­xx]¿Îö±g¨ûA¡“œ¤Ø»x`£2U¨ó¢Ñ6=×ÇcI÷÷uNìCDË ÿKšGÝìÞ#¯ꑤzóìÖYb”1„ˆ·©DG…Þõå0$^‡Nºç.9SR`Zò Ì'›A6MÚÓ ðß·ÞÿìööºÚÔàq¿·»Æ 7 !Å!|cëuIfñGÈÞuD9SÓÇlhŽ›G¿Iu"sQ(çBÕ)𬌗‹èFX+< z{¥|¼1 ÚfyNZEÐÖ×v¸Ù¹Â‰òƒlŸ÷ÿ²!© :u²k:‹òI±<™[äm`ŸŽðÓaÔT£ñ»úÿÙ{»æFŽ$A°Ÿù+R¬í1BøQF%u©DuWŸTU'Ršiã`± I¦ @¢‘ VQïiíÞÖöùÞvlÏvïeÍn×llÍöìí¿¸pŒˆŒÌŒLd‚`58Ó%232ÂÝÃÝÃÃÃþ2âÿ©\ VËSAþ'(†ôšž3eµ©øTY‚ L…­™uOÜÄfáít-½Ò¬¶Z”É0=0]æÌËM‹ŒCl”é‚{NãàóN÷óL Ø“>ˆïœ+ß™W[6õO•Ib'ÕX ÞGÍ¿6hqš´¤’!muqiþ¥ @ zŠ™Á'JƒPu¡Ð ÌEà‹?Ol©ÀƒÏ ‚“»?Ÿ¸~á¨8ØB‘”U#ž²QËÒƒ}¾ÊŒ=UúH!ŽÐÃ,âþÊ'2km 43ªÞ¢„+©UKÐ×Ô‘ÈpR…§ÃȹòfÞÂIL)È¿Ïs6Á2ʘ‹Í¥I‚º*Ö"ÈĆ!#4¨ÎÛH#gä.¼Ý´¯ãåS8 †?ÓPp§5^þxvþæ{j¼¿87œEÝ®"óèW¸©ãõ“¼‡4ån )&\ º‡Hà dW* ¶‰i @_ìÂ(»ýTx¤‚›=?ðYæì@‘ù•§ÈWÃý,±˜ÂæA"¡z0 œ™µ,†,ôké¯ ‰°:Q×…ýrxp¤éÿãÃmþ÷Õÿ?qæ ×¸ç{ð$¯ç)Z™üÿp:s ÉŒß*$›-^z.üÝ7M%CE“ç"¡gköFÎt°„T=§g€9'€©@%Ä7éñnú6áwâ`µÄÃá‹ÆM‡mêY*BOQhìðlÐbÖºªá$»|ðÓég¼j=t¯©1‘Å!æ>“ ¶ÖtžE kJà_Šà}Cœùæ‚—UXlÙÑÁ‰ó:ˆX,3îN Vl ˆ ‡óÅÞüWÐK^j±Å¯Û e2Õ *˜$u@CÝboKš!’žÄÙâ ©gÿðô¥Ž\HƒAU2È3+ÚÆ{ªs%0? ã6'oÓ\\1\Âyc,²Þ—ë(}HÜl²µÒID¤lãY4›lÆÖù@²hLÇÐЕˆZ®;úìSâ8…ÃÃa‡±B12¯ò:É–ÉòsV’ÅnX$W¤xyÙ–ŠÏS¶Lq„¦ÄÌ€ ‚‘AdÊÐk›V¡pŸl²C2Q5ÊI¬šÅä›4‰4º1YÃó ŠOS#õË]ö ,MW}¢º•ÉuÓça…oëØ­wÿ_jÃ_,ÿÏñ³DþŸn÷Yg»ÿßüýÝ[þµíò)›Çº‘ƹÕHiXmø1‘Ývk÷whöÞŠµÀ=h9gtø#Ï .µt$p_›¨V»“W>ªÔVš*Ö¿ÝÿÛÔ=´,?QNó)ŸpLåm7Y±(åðR^ñ-8RŠ¢lºÜQaùHò1¢.³Ë dH\@ʧRH1yÚ¹5Îf12ܹXÁùe¾=ÂfÈŸv?‘ §Ü±,ä›ù*Ç+ú²°±G$€±Ä7"-§wÓ‘¢»™ZåM|wq$9Œ˜åÉ{¦F7%ïͦî†Ø}s #ŸTG]¸`¬]l-Ê2ùOC*›}*E²~r(•-r6áVÔ‹\½=áQÆײzWìó‰—×j¢dá'Ç~èˆ}o|WGL  Š[e)?³”ωç«B}%þúÕÀáü]âœÜç‹"ImÓfF_üX›“zÏèËìA™† 9«5ÛÑË)ÐÉæþí+> ?.ƒålœL?gÈ~Tã™é,\Xz^‚¤¶®C•€|=fÄ#[´k\†jÇo%9¯DÒc¬ua/(îÕ |"_TèíÄ~Ï,öæ[R6Kñ†eÛJýã8Ù.$è›pÚ]Ý2Αìªr]@˜Ë²<ÒÜ©JŠ‹Hpé¥tOŠ¯Q`+(<#8ÄT¹êM9t¢Ì¯:ÉWY)䙧ÌõX…ØF JÕ_á$½Àü™r¨ T³‹sr ŽS—ÀÃoj5 œã´ ,Ò“&ð€kÎ%$^WÁUbA@š6í‰n0Á)g”©´é–¢M·NÚ«ÖNË0ù¼øo¼Ç¾bìøïN·óìXÿîló<†øï·ÀöáßÚÁeÑhp-'<³† D’ 8tC¢yƒ™R ¹Û!Ýù¤Y3>Ãc[šñí{¢Y® ÈóÅ÷ûî{2i-A=àm7Ú¸¼âܧ.y.:}óIî¿ä,ž–§½`6¹m"-ȼЖ,åDµHeˆ{–6¡cÔéÖÈ¿‹[–oM iœÛ˜Dq0à ÅlG³•\} š¥xÁ¡O¤z+ÛŸŒ{<=Çúì°(pà@¨¦81ÇÈ}éü\ÜÏŸ¡F65Ð%§¢šØÊ`…±5‰«èarDm»§Üž0Ü›ˆ¿‡« _fÔÙÉK™žEiž½IÈÜ*R§fœYÄyÎ;¥²:R)Ú¤0f²˜w»*‹ðM®sX…Ha¼­®CËÅYp¡îàSLø¤¦HúŸª¡Úa’j™¥EqѺ‡³.LðÎãèà(ɈF»¢k²Ÿ¹voFHŠÂÁ€Ø_¸cbeNŒÕö=ÂóÚr.ˆ‰ :º}þ;ØðOÝÑí'sw°z™qê³+J«‹ô¡œ¿#Ï7,zUpªñÛùs““}Ov–£7^PÂÛ[€ÿÂÀ Ç©ìWè<¿âõ¿’ yõ?:‡}ý'ÿ¿]ÿ7}ý—Vþw°oæ,áñM¶;ÁÕÌÿ6²¦U»kã~fˆ²ù&BS?׈‡¢Ç ™ƒÑ&–ÃÅQ°)ª&3r¤…5vÐ6}4cªúÌÑ_XBcHÇßÜîíñþã3Õ|* ÿŽžiõ?:'݃­þß$ýÿyC/ùÄ[´>êwñi£=\ú“ÈŸ (g…J*/qÞLl¼™ƒÍ| UrÒMg­Cqaa6à} ‚K­ÒNl¹SWU耇#o¡|+ë ⱎbÃstÚSÉÕëý‘\‘ÃKEþçwû>XŒu¼ñ;FÀ¦|X%{2~\~?n9rfÉÐÙPFŸpü¾§ ”yõ&ÁøË¡–ZeLœp¥¦*­äÖÎcNµ¶œa˜Œ=Þ·¡Úœ™gã#ܽÞÏ(î¼³ô*œŒòÂïŸ'Pqïºm&+šfV"76$Üà¾qý \@m¶ñI–‰Ek@Ñ3Œ¬ðP\j”vs9lò ƒg"­ ŸnJ;‰ª=ÃÌú™9î2Š^Â>½¡»H–èŽéJÚ·ðß´û FUÿ=–`¶%À”¢óiGÍìÁÙÁäûktíŒ(D@AÚ4?­ -%ºÒaÐa¥ C„ϧL.» V•ÉÌü‰-±–3v릙¬]£f“ìÿÕzÊÜÿ89<Öê¿vŽOŸmíÿ´ÿ§Áx9aÖ¿¼<Ç>òšýÄŸù‘ïNˆšNÈáÔ›ÁÊJxÀ9m/Ü÷t‰kÆØAªZ“ÐópLˆbHØ™{#&ѯý2,UèEÄظ -Š#z¶ç4ˆm˜Áâ ¨’â?Ä cdÇ@›@);5¦ 0‘êçâ2= "1$f=WÎO® 6@Ń÷àû•! çŸfÅÀ­ÕoßÃÌ:°œZA¬`ø&‹A@:XÕòC63@C‡6¬‹$X€¤Ñ3ø¡ŒÕ0„W£„öÉfr2nØAȘ‚Æ’á‡VŒAÔ\ˆœÅ=ʘ¯’,‚ÙâiàG}œCJÎë&cŒà±‘r”™ø&dºÕˆ5g» h)þN@óLà„‡¸É¹w&hÍ®ª©Ù²ˆ‘˳k"»!¤Ä Yœ/ý|vM‹1:iimyè³Ta*X`G,Všlý¢bV’³O–’Æš@õ©¦¤ëŒ½¢lì—ÐB$ð¶è{?´7)©R.Œ%[Â×ùi»*,˜3]br©éXœŒW+€…Oa·B`UÆs *\ Žì&!Ü6ÆÍCl“2¿ñ˜’ÙLì˜Âøl7€öÕP·8kºhžY‚Ç!¼”²›Q|ï;ž¯SÖlŠWJÚ²@§нh†…›i/8Uöƒ74Ô÷ªyÌDCj! ™ãÐsæ Hf†¶|™(“ÒÆÉ֎҈ЈÝòãlÊdÓ%Å|J£É~ A3‡" ÷=Ã]ÄÎ;##Ì}AM%þ€Ðf/./ÕÙWàô¸Ð呇#G«š'1JG ¢45´z"p§hCsXtˆ¯à¨ר{‹„ tiĄdzz)x4áÖB2Å„ßkã1‘µe' Rÿ ! Bc˜»ññ(˜»k"!µ?îm»HìdâY°¥á~»GÇ_Ž°i)Žox¡*¤©ff]»ªÎ%Ȇâ²Ä?>ʧ¾,éàת5ö©Ö|¤¼jE1Upc›ù¯Z„³¬øl½‰5Ã-‚éПyñ‰«N{™g¬˜©™F|éOöÉ8”E%¦®"”ð‡è>}½–±”Ön> ë¡™§öl×â©uÍn ¸Œ`Žv㢖Å9›”¸¨[ÌMÞ:¿½lZüüá…áëEÿºŽû‡ÝNòþdzîöüsÎÿÙŸo‡ìÐ]”úôŒtÁ$ƳœNocȬºõÍÙwU<ôÇÞÁ2òbeàFÑb° Ç=¼<ÚcâÉoD¸Z‰?Lq‚\Jšæ‹º“µÕï؉þXîï± SràψÅàcÝH'Õ’^þ½ã/$­h³Ø ÒÅ ?^ˆCe9 ±¾4˜£wMu­xC›*éÎÑ1 ðÒ–¦‰lmÑ~O—)eGz–½WˆãÆŽ!œlÂBXTH¥¤h4Qà"gÉ"ƒa½Ú|HüÂûçAqLeÉ¥ OF?C ò8Ê[Šô{Jþ ~3[…Έ7ôÑõhô8kC HF’ò"CŽPøÚ *¥;M$$v‡S»£ʘzW]sW]ÞU7««ÜÙK›¿ŒìœÂÌκ…;Ó0Ô˜b@ØrFÚL¥0ÈE&¨Ÿà“{aÙC7ÙC—½H Q$ÍÌÖ<Ûû­±Õ‡€æÝÿ:éÙc9a¨2ÍKÂZef^ÖîqH}Åxª˜ËmbDUÔå6Ò… ¹ˤ"! d¢cB#ÅVŽø   µì…äëQr†ëÐ *ßÉ›ýžÓèt•#“!yöáö—ø”ä^Ì„!*?1ªXxxnÏ…àÒd 8ªÓÒ¿`<ƒo&Æ}+¨ÛÚ ²Ã fýÀ]h¡µÚL(F†2'í©·¸òö¦þ4òƒf‚ |²äFÊ`wÊ*Ç:étvp Ø\BôîÑñ‰özDžŽF#ù4ó^GÙ`Ny½Eyßæ-AÑÙ!è_RQ?$+!¥3§a²ÌSÅ×3^ŠJçHQ®£hÎÂøà°%9Eï3ciñ®üþ‡oO¯Î/ß¼ùŽRãÖs¯ígûáa´´àëœlE'xéŸmea; šã0{æÔ²\P• õÅÓWáÓ—\~àåühăÔ-çß:a´¼¼¬ˆ€1ýN_Ÿ¿:ÿÓàü Ë›2\FdÐ÷Î{šêÒ$‚±±"mâ%ºö¦…ˆ§„$[Ð(ÄûeþHž³p% !Å)}¾{õ¿ž Îþôý×o¾{õ’(èžÚ4r(£* £,SäE¶<%™6˜¥Bƒ˜§ ŠPÍ®Š1&eËïüw^øôŒŽÎ¼„ØÖù[¥ýO֦ɾäèâ¾°•7Ùö÷àä$™ÿï`[ÿçí³ûʸ¨‹ô«˜[ÎXô¾~{¶ÇrŽ QM~Ó—F4¸šCwòIRr›Ô›EŠ×ˆ™ºx’ÝÛ·¹sLxÆýº¿J*ˆ?kÓ‘/zô¿ŒŠ„ê5üÁe †îÂô©ð_ôb—pÜAü̦ÙÍ,÷' ¥©où½Õ8Âg-"LjßfŒ€äEÚ‘q/ôoý;ãšIM<^u§¶/:mi]“g3ZS˜>ŽÍDj_§3M p#Cž7¥žeG=¡™8YÇ”®CßÒ„š¹Áä¢9%Ä’<­yB ßq¨ác»Ñ3ïC´Òj‰ƒ‘)“†QÒ+&sž¤Ž¯hEAŠjLÀ[p9GåÙ s¦'MÃ]ê\Qþ±ƒÛÔQ’~×Ár2v®É¦‹,cÿòÒƒ£VƒásE$dM¸S=Æ¢#yœÕ˜%½dßJ3E™bÕEô k…%Æ4Y2C*ý“øÏta0ž¡ÔÊù\Á––æiIÒóÏ匬•HOÒ dqSB«câJkcQ-iþ4•J Èp8¦J‚†4ºøD¿Ÿ–¼qa'\›e“¥ã£÷&2w™Ê V]¦BhͲY‘à÷Áâ»]%5³ZJ˜;´² ÖµðÚà]Qu× 3ÏòÀ|8KSpÈ@Losµý*8›º_?åÅ5‡Ø&dé Ѩ Ö°Ú¶p,.²6/ýê%°:à¨ðõ­©+Û•Œ~'ù…”eŒîÞŠ®ÞÉÏ+wÚ`-~Å®g%†AóKü†=Xñšaë*Ð(àˆxh³u5û3%YNXÍ‚¢ÑC‚K0K[‹’1P?‹ˆFD>oÌo“ÈÈŸªâ2<<'£ì*&ë¶TH¬Ç|²×C"ŒÁðg¹¾@òSýš¡“hè§1p³,­,%—[S¹\c6£ gÐ €LdòÜôô™qL™U²ú˜õ”ËI¼÷ļ•@»ð¤ÝÈýÉ`ƒ^¬³|ËIe’^ž.Ïæ ~a‘“$‰Åzƒ9÷Ë”ÿC׊ÕïäÅÿwOŽôøŸãî6þÿqÅÿüDOläÂq—l©”¬ˆ¯Ûíñ~ ±»OÆ*é;£a }çÝšWЄÆ|DÊe›öh<¬Óõ@qW—Ge£PŒÍæ}gò!=,ŽÌem ]ôSì áô´œ7ó2`ç@ä4¦ãÏ‹ÊÌËÊÐA@Å{ˆâÐ7)z — |œ´pWbœ<ŸMÉ#_…Ñ1–«æ^»³+-kP]ðz-ÉÎÏ3=økcæò€ªA9âÊ·«Õ^ZeÓ`áÙ¹»e;Êûó^ÜGUNÑzí‰>í÷bÉ= ¿[ÏÜ5J=Yx"»xE ˜Q0%ûëΞßöÚȼó…?õ#ÿÆk:c7rèvNX{ÏûÐ&D~tK ¼°å/ݲþ{Îpyå<ùìóNÓt›‚×[h.ÚQ4]‚÷FK¦¢×ó¹;€þT¿¤ü°×e"ùwq¡•ñr>ñGnd¼+‡ ú©£rv•žm¯ o\ü¼á©ÊúϵÿŸ&ìÿÎ6ÿËc°ÿÏ8·äXÿZ»ÛßÐ*Óò'†}˜¾M&,ÿT‹XY¿¼Ih¹~h±ë6î¢å$úk‡Á"Ê7FñÖPb'â”2e–æd#³Êè•Xï« ˜ú‡H’0kÝF Cÿ£ß/^ýJvŒ3²yX¸·ãšuÞ½º½m€y£¶yð‰Ž @¸R쎢eZlþúwquÄœã­Þ=fî‡Ù?æñË|^â^.pƹŠp¥µ*Í ÙÌ+YÔ0U Õƒ~ѣǿ¸ •ÂAéA9 ÏX¦øgÛ,ô!ý†ŠVÇ `Úƒ€Zºeêµÿ(|Y“W›ëÂ8å_Æ…Ð|5{3 »~°›3–Bƒ™.‡å\û“±¹•£…ç9œe6ÎúßíoüÊv¶c½â+ƒõcþÄÆÜ¿¤sP”[ZPE¸gE×ÕÔMúžÐ?é¶úüðÀ越¿ÁFÌW•í©Š¿ZÆÕ駒ÆŠNzöû©’þŸ…?Š'„O.ý«åõî Ž ÿOçY÷Dóÿvº­ÿgóý?3dX¦_ÊÌ"ÉwïHBø¼ß¨ÞÉÔòÓKþ)´)H{=Ê£¢éoÝ–C9EH=êó‡Çä!ýí$~ýL|üY¿oQȇØäÙ>Á5jú™ºRŠ5–Á«%!e; w2¿v‰7]§1ô"ò"ñæPWd ;§qåN§JWzêÕ`äN7.¤<þ,Ùñ±¹ã“d‚QF0ç™ñùgñ@’‚¦Õf× ï1Âõ8åZ¶AIŒ®=FØ‚ßBä£t“Ú¹/ØËqÜËIü볞óŒ³æg=ç3ç^Éz›õÓ¬hå‘ô?YGý1JW¸)¸ýá2òÂyDæ‚RÁçèÿƒN'¡ÿN¶úÿó Ï”ñO1oôz/s¼b¼šb{2÷ÈÏÿdù§!1±½ºówõó¿“gÇ[ùßTù‹Ìq¼AMÍÆöÝûúÅÛWͱÚC­w>ß‘Œ¥ø¥Ø›òjà.ÏDØP“£å”û„d׆ՆíK!•ò£ZµB¥X×±W>Z,£kùô'™G^Ü }+6M@êNœž?‹Z¸{î9¯È¨WÙ³ÑzÎQwÇd ‰À~/2[žx¡AÁÜq‡ß$.¦Üº*ÉÀª‚RDƒwÞí^ƒ€›, ¯|pmúêw<¯²Õ§¼5ßcïuS+!ZÌÕª`ª†A0ásõ“¿ˆ–ò×ë}M^{îLš>¹*ïÆÌ `‘;…بäÒo““ˆÔXeÕb´eg‘–!áóø†ý%æL¾Ý€cÅWòèΚ•œ5þurÞEÒ7²&†h@8©‰õ¹JŸ©ìyÚÑçEŸ1'ÊÑ7™mf8™ó¢¶~žµhì”ǼY$ÒgÒ<|1”bçV4Ê®å(Ávm–pÏùUz:šÿóö.–m ù3çÉÞø~×V™¦­|j¿˜È÷û[H>~KDoccÓFž:}¨¶7ÑOCa‰q0_„¹ åÓ Ëð.=Är‰91t¼61 ÉjÀ¦{pÐÌn/UäÙ“²³¸”àˆ¥Á”:ßž¼ÚVl|%êm½ÄïÎoçž¹–ŠƒZ4 .G„†Þ¾•ï6]ºþÄñY8…óü97 5„þ¥VlH®Ì•äw¬w:ŠMŠxêú÷#Qƒ’Pă"Z7¾‹O€pÿØÀ‡Ðc#6j*æb ¬ÄüHÔ"­@ɺ×J¸Æ«ólŒž3L1/‘ÒrÍÂþÂœmZÙÈ!*0ˆ™¨f²ï2MòzÁ¨Û—·Ý•œð§^w"tŒ”ÜÙGÄ:a Ô÷ÎŒA.ZQîݾDÐöýòtÉ`3¬k©Š!]È’R¨U¡wG@ü冠!vÕ(¾g0ˆ%ÎÖ«‰‰Òpívã—ܽ)12hGŠÉOõåð%jc°¶-‡þBÆù¹Qã~ôgS±4n R« j2 ôüc!z£'%Ž:C»Cµ}&à–±E6¾Z˹²AÙ Å Üͽ2_7džÆELeºp$§çêZ$žÆ¡Mà›ÅZô½‚_ã÷0 l›OQ[”:ÖhwÂ(en4 VvCûÍŸ.'ØAŠD 3”«.4”…p›C‡{Y\h«”s¼ƒúPQ+¶`+ÞBÊp4w ¸‹+ E—w‰þGwž:“tÓºÊTÒb./¤Éìoìl®@ÓtRã49Ÿ\u¶‰XSËY¸œÏƒ„îÝU§XἨ~môc }ÅštCÐÈñKñ)h#Ž½9iG3…W,£+O¹±HƒC1±Ì”“b(OÙ e|Gûx/.¡:ø9Ä$ Ie4ŸO|æã–qf“[pË«¾o´ðšŒÄÕ̵ £TÉP»€^©É6¦tÅmdÐ⮄z³£ð¥3%[>‘(6 rRKæÎMð0£F8ŠÃ—ÇU ÅG«0ƒè¤Cdö6¬´·ò¼RˆkG\›M 5WÁÂÌ®T¸L/ĺ1Öï]¨­sC~c9ëWÙ;Pvi^ Ëeaϸ,¼›ïgo9¸\ÙýÔVw²qz¢KY8Cƒ?ž½yÍND ó®½Æ:´qÕk©,­:MâJ#ÑÐ!øäØ|M½0t¯<Ž„+Ý,€¥¯à¡ ÞK³—M‹\Ú2Wxá7*)Š µ^ÁZ†ÓTkB&Ã]ÀFÄ-¾)¶Ê¸‹‹a_ÚlFcRˆß÷\Ù.')s‡‚Õ¸õ¤]J1Ñ"Ý¡4Ý9)RFûΚ¸ Ñs§›˜<Õ½Eé¹Éó9Jï2}âónܬFÌ·Àf¬r~ñç cȬ±ÍV*þK«Èýe•ÿ·óL‹ÿ?8<ÙÞÿÜØøÿs¼ŽÊˆ¥áŽFƒÑ¾ )DJ‹5¤ ãÇ_»‹Ô³œê4~û…ó<ÉÝ.ýÉxF ¥Î€§-¿Ç?v䋨ô»j*y%BúòkÃßg´™2€7‰ÛûâƒL ø_Foz–Ö¸!þÌŸ.§ƒ‰7»Š®}è~È7/ø½Ý^OÜôÿ*Ž$ÝáÚÙ)ô·“ÀZÎëåÔ[ød)úÚ¿ú†ì¦î„_ÌŠ—çÇ>g·Óa ¾øÆÈÂÿžû9„þûƒ;z×ë}&w‘íÀœŒ=öÆßúlR¤V=Œuá‚«™ÿ aÊ'w¶Jk'wM‘ÙŒcZV«Ócºhò¬ÍôFHV,¢û,Z0kI71)±&YcÒ@h1*ÕßZ,į×cRgèH‘™B‚âˆlO œVG‹G»œ±`ì3!†°™‰Ë™0b%@'ÑbZ¢Å…˜ÿò²Å…¯8¢6˜I0­‚nßÝI/°§Øt]Àï}"ÂD~V/vÐÈJÝs*Aœ2„ÛSôÛþ ÞFVdàð¯B"ý•rPÊ7Ùx#…{Bð¸4¬@ s ¡Š=\Lò…””.¡Æ>nbeØÈa<4=–€D<îâj©E£æ“!ñ%¨‘ÒOäPi'rßA ¦ûŠÈl¯$[Ï3ÕÒÖHßûŸý,Â}w2‹ÁŒð@É AŽýxxœ¸ÿrülkÿoìýÿÉäÍâ5á‡7—?q>¡JAÊGÆ8ÈûD½·‹7Ê›± 9ÃÅ/ ÷‚y6åõì~êzØ#ÚG¾5BþL¿nƒ·¿ú»ÔM ™·™Ã¹ƒŒ[˜¿½÷þÌ£·æÞåbéG< ?2B]%ª„’½·œ»ûÕÀ-I ›æ ÊJOV L€Ã}Xôä3yÐÇó-3 îÀ€{a þ{Œ w´ÆÎS¢t.–òº'¨Ñ3ÏÝFÌ‘3qÔ›u†É©ÿBòq]ÄÕ‡~‘Lk‡ ¥)£¿µ1Iò'´t,ǘ+îLzÒÔ µG9i4ºü´xœ$°œJbL^‚%0›ìăGY,‰â0O$tÜ„ÙÏ@ϸåÈÙJ!ùùaš-Ú*Ohà$'Üâ(,V¶Í„¯öaE¥°„è.k •§Ò¶rDMö_ð~0œ¸³wµØGÝã“g ûïd[ÿm“í¿àý×ÀšùǪqcáf¯ Ÿ&n1ÃõÁ/œ8uŒlÛÁ„Áe°˜º‘Óƒ£¨X?eG¤CIÇ–#ñrVH;Ù¯t¯¢`¿Nc쇲L‰HF¨±BR<‰i\©­õ(DðÈØe[|PPôXF·êÑ­i]Y£1­rȲä.?ªpÿ˜eq(?6;q(>ò%|¸Â¸þ‡ÙrZj`ü²üÈìt¤ÄÈ!~Y~dqPSB‰ÐO«Û^s?ÖÕËÐ[dÅSX-Ò‚*Rt<÷HPEÅ ðBñÓèýº°°S%yÉØ zY&VYq÷ªôL©«qüb06Šßâg›Dˆ'Ç´<&&¯ƒBl¶*3›†šd¥ì4H’`œBî`‰yyØùÜ€‡·ê•$˜æ0Ò½QÙã¾SÖoÏi\CTsÀ3}Ýï¤Á)6} ™T¬†ö)Be(õì}@þh÷Yƒ§šÆU@Qù¡²© ðN5®šR¡¦†áƒh \wIÙ°Ò@b˺AêâÄ|wE¹pØJyqYäÿ‰Äl%¸B»à²D ¼ü'Ϥü?‡¿9èw¶ùß77ÿOô0Ä›!¤ÆÜ5$4Ž°M¹MY&äÚS"nLFH†â;ï6$oÀy2+ ̵ÈbqŠo#FX<ÝXœ×•ösãó^¦ÐÇûàŽ¢É­S™d¡ØØL©Õùöß(ð#o•Z@ÙößñáqÂþëžnó?®åç á¨Q0&¼Þs–ÑåÓÏvÊX„/‘G4[•ã2ðR˜DqjǦù>!ûÒTùr£,–VR?‘RòG²‡‹—zsõfWòB6N4Xî Ókz‡“¹É9ê|&k÷ öXÉ Ñû+Òª= F.Aé9y=3oƒ¡3V>®±¹Hˆé™.°°]08ˆ)õÅX¤MT1†ðÙ^£ÝÞÿåúéË×íÛé„lwƒo_}w:4ÕNtóI ¨ ì¡õáÂÛ©UQå–º–*ĘœHªRGöñà‘™è! ±²äæÍòm‹¹*Žݲ›{›°ƒ¿ü·ÿò¿þû¿ý—ÿðÏùçÿ?þë¿û—ÿôÿç?ýç´;UPVs% úá5l&CwôŽÍ7=)¦ç#?ϱDºäA¢6Oóèé×?lçÉ4OŒ„,&Äör™ëä_,UjÑçH¬ÝTúñ©÷ÆEšøæ8ž”eÄdg\½ÓFš×?m“Ïf.\e{lÁ¢¤ÊºUE˜±®kÀ< ²ž©û\½Œ}›(2KÙ$”øäB+ÐÖ·à˜–Ã¬@àùžCŸÇ.V‹"M~Õòø—0–óœè›[5è›þ$R´âLBé+©”øî ù‘—hDúЛ)YðïfjÒU :e)½/zn¿M]< I32ëiÑvX# ²ãÅÔ4†ÔÑ*Õ:õŠr© Ÿž“¹@Ë,+L0ŒüÉ„k8(‹|›MÉàNÌ_á|nšØ§¢A YлéŽÇ>;/ࢗ…œ­y*¨8Ú³‹%{=±©[,­%ê²n,l^’+ƒDü¼U¡êß‹iÈY »^¬æÎÙÃê}EkOûãÏ!­þÇf²Ÿ3•.4Vg9¹óI¿$T“µå·ï÷:N×qiÖ5¥ã0}JM |öùA³¦yÕ ”O9 ¦ó‰÷Á à¡É41äéHÿÔÖ@”“6ǽž²#N·¡Ý äÐå[‚øµ8A=ìÖij1ÝIóOæŽpKÏ9ìŠ3ꯃaù3xøTªåï.¨‰ ³ “ë²[Úi‘ý›?‹¦ì½Ð!3‚²X¾ºö¸N‹›¦ØÌ4·_$ÔÏŸ‚ÿ˜Q%l”´µ‹Û˜ÄF=œgo&õ±bt’ú:Õ5º‹8F¦á+¡›51Ú,¬0An؇TIëôZÔ@~•ú–sÐßS^Pÿ%ÕGÒ?u©üíÐÿÅ+FúÃN¿î(eé1‚ÄŸŽX|^Lü‘Wÿe±¢p^¤Z7+w¬o@žyQB¡ŸÑóñÕyèI &鲨.½(•—É»~ûÒ_„‘.‡¾Zù!ÁCP)Ä|9l9G} ÛÀ}pÍÎ辊^O}u¥¾†y8XÏ ¤)xãIP©„™—TâH§¾…é8Ô!ˆé¯,ŒGì¡…·lzN§FÛQ¦l uÚ¯à4³Bw¯=$(ª_¬Þ‰1²ùîè]¯÷ýrù„¹"bpÌá ÒÃAg þ¿$Ÿñsfß™0BÜrbû€‘@ùLsXÎË‚ŸÚUÌÊôɤ—i*à¡A`ú…5ønT¸ã¦VߘÁucvŠ-ñ"Žùô OxÜ2"¼ˆà@Cˆé¦7qje7¥xlªº×µãЧ_BT_“±¶ÃùÄööÿ1üt¿Ùžºó½¿éIð›Vçî„ÞaÊlR8ú9óÒ‹ÅK8òm ÇÇ9ZyþãÙ›×m¤­iù—ÊŽ$4×:#g¼.Ј‘Nÿ¿Ÿ"úY¬sÁNÊ+d¡ qø¾e¥ä|qo¥sÔÜ0N"8øÍ2ŒÄ}UrïsËJŸVZ2V¢ 'žãÞ¸þÄ–²ZÛ¬u  Î0VÒ‚ÿÔf?—1`tî‚GÎsÙ ™ŸF=ˆd1SôL ⎠%i߇0¢Žó7ÃüŒ݆ŸÂ¨ï³çÞù.³*.ÏZbØÂ̳K´ÆÝ®¿Ûë´vÞíívwïkŽ® /ú¾œ Ž?éìøãŸåÖyØ\ :»]P¿Që9¬Â4y f·ÎÈT!q°0\®šc¼Œz͂͜VQ1]á#¿G× €ýQ·=|x_…p*RI·Öb¼;‹È4®o²bb… !Õ ‚W -a9¬ #÷O—d«>ô+̉ÙÀ/bö0Þ.XððÅÜ‹a¶N*% ÉHçUý.Ù‹ÅÕrêÍ¢Sø+‰ ÉSz32o"Yð \uð\¬Œ?Ì®Yl°e¯°òÍ nÄôSj%VvÓa•üAζVÙ­eÁ±t¢/î—ñù %O¿í‡÷+Å|NÃÚ]àäß[åðG¦Ç˜!jø†q8¢Ö¿"zò×ðW'l¿óÈÐq¦zÜIÄ…²ÞPZ?à‚ Ó°Û#“Õmö[»¤ËÝÞÝî-Ñ)ïƒàr÷¾Vi†!’jEóí @û÷-|r(ž©`ÿyéŽÞ¸k]‘åÙjæÓùHÛí׺†°q/>ôqÛóÚ½—=YB’w$?’žô7 ãJ€F¿uD4&¤úáªÁZƺd«·êp«·êð±ªC¾-¤JÔWß ¯ƒEtM¬ÄÕÍC¹ÛÊÔbüåíªª*¡8Ð’ýc¾ EÛIŽõC©åî“;úî¢÷uvߎŸñîw‹)!ô*Ä §þð㶸Äc%´.“úW1ý5€*NÝòÉxTžŒ§e4¨7W­ìÂ'³FäLÝwdÓí‘ÞÄIçnU»í¡;–í/ °¢}ìÍŸœ]zÕÈHÊóÁpÊó[)7Ï‚»`]¸ ‚q­‰,rb?h°pæ êG>Y©FÁ²dABŸÓÄ›eiÒ)˵Ô致ýø0þN?ã¶ú~dÜý'õ™úÕ8Uû¢%_ÝôËfØÓ–¢˜›_My7Ìx7Êx7V±m¶ýf!°MZ€ÙrCÌ‘åÄ]ÀýÔ)ó¹QέyÈËöÞ½­ûâü.g×p£…òÛ÷{³?Ö}îb—Œ²Ûrvq´Ý~:TwðÙ´ {N·þÛ?ÙWH¦=d=DꉺðÏ!Ò(…í+ª„¥`3\#6|œÂ×wÓh²aÒâ5M6Œ‰ÿÅV›9—Ö$z™j@+8Ž(Žnc݈Râ059†`¨Æ®Ò¥ Nôæ:tón:(Ñû n©xòÅ\ÚºëÀ¤¼vï¿´¾a¸®M†¼LÛ¤KÛ¤K›–té¯!Õ’ ãÞ¢3OŽ†‰0$%giJ¡ä­âØr^þ”­IßÊYÅ3;ŠÃÊ" ÉìÆ[DJÂ%ûñpéOÆÉk¢Ò:íO½R3<³1j>×a Ï‚Ì›Œ5#g,¼‘GvÂ{=ĪÙv£Á4£½.y h´!i*D‚…åÏ$¥×9 MˆIÏ•Øý£(’Ÿÿ™—é,Ÿ:;ÿsçääÙ‘–ÿùð »Íÿ¼±õ?¾¡¡¥{f©˜¥–" 3{¥—HÓüâí+ç É.õ@„5ÅœÞÏa0“nfÆœøcãcÐ*-Þ1YvØoOQ‹õ‹Ñ:¡)2DHì¸Ïõõµ[–ç4•ƒúM7í›nb†T_wˆKGE¦ÃP쪻…”S×=îòÉ”½“[Ab,d• ¦O¿$€ü€OÛðRñÅß‘åxøVú,cêgËé0™(åÎ¡Ý èë;ú˜`= fƒ”6‰W%©áÒ{*’ n3)§ÕnÀR0ª8¤a‘ž£èŽÆ÷äTEîmßxµÊX‚PÎ}¯éϤ¶¥O©vdßãv¬–œ–E÷~J¥;‚ËQe,ua‘²³y¦5™™?ás¦*Vç6o ¾›9à‡øC TYµ ÁÄ\Ó:BÎ5ÍR+^QW(™±Ò%& "Ž_á0ϱ‡îà ÌÆ^qþh0=øöà› ¼ô½ÉXÐ"$¢Œ{LOåŸwêcßǼæº$ cN&BŒqÅRôÁ%Þ3ÒÐ効8¦Ì'õÜɾŠXÉX´šEîPr¿¼‹Fb™hôy÷Ø«¹…©§D/°*=zÑçÉÀÁXÒK\¡4Ç_á¿ý XúÏáß¿I>êŠgòZÔ>t5‰4[”.DEXøO£åÈãKK dyWšv“mXç¾oäö8«½RœzI8Ó jÕaRêÃhÅ“›€†¼¢ÊõdLN.Íì àK}1eEcBM£)È%*Ä&Ãvaò¢i¾õtPÇTÿV™¼FP–¯Eí/aù¨¯cH}žn )Õ]£åb‚ñ ®,ã2 \$¸žæ‹àÆ{jØ­èúrß$ Ð+Ò‘ía30ßæpÞ@5›•›ã‚¯.úÌ“ ”9 :Pš™[•FV¬›\<ªå`Åõ±³F®‹~)ÖÆ‚Ì›¤V±¾3HgoÓýŸt†¾ÆKÝ•ñ³ °tŽ6µ6ð´©Ùj '´7\ ?›‰•ª­M‡éx7ÞŒfš Ýq•É9±_ðtHf\ºg7 ÝÙ§•‡BãøäÙg°ÿ`¯ž\_á­GÖ‹¥ÜZEhÕ±Yzä4$5pwÿð„ƒ8ð¦óèŸ[h5’¦Cj§ªc¢]/ì{3I_fPŽiñå’Ó¼Ÿ 8 í§ÉŸÍ¼ÅÀPæÚIEÜbŠ.ŒUbÓT°˜xt½‹Á@–Ù¼…ÀD‘E0u(ÿÅ~ N'§Í%oR­F©“Z¶ÒfC5"6^Ê!RjeOº+Š8É²^É^)«!È?ÿgE¶ÁÌ—e²ÏÿŽ:''ÚùÿÑáɳíùÿ¦žÿŸRŽx3óÞ\jAq¡æ'¢¼¹_¬¹Ž‚¹œæê,Z,G4•>,d¡îòc«Üž»¸’c¼ÈŸfã>ᇠ_ý]êɃFcî¸ üE ·àäpæ‘ÿ ˆ\.–¾0{ð{!'ð G~< _¦q€YmZìµ$´mò ój‘{w21Tµ'ª’èG/ô”ì¿™Uíþ{ŒŽ¹¼=n"Bû²öªÁb¨q¯Ö´7Þ¥d¬vʇ e¶ËºÇ4õ?ðUxåÂ1XQHl(M2ý­=õWÞ'{ø-';»3éI3¦žiO'3¥Ì´’áTÌR4ˬ$©1X¬!­ãQ Ó=jFË £È;ïn)L=Ç ƒÃ,Ò4€6 çù—ü^BLñôc!Ñ ®e>¢gÛ:/û.ôàr‡bß%&â@!îüãb!¶48UI9 ’ —âdOº=µöÌĨÔÛìè×íO¾ý?]FK²O!l1Y†äeñ@Žýxtœ°ÿŸ=ëníÿMµÿ¿GŽ8å ±)[€ 3Ÿò01Ãßx5˜ú©ƒ6÷yOŽèiköoÍþ5™ý•2ßÖüÿ+6ÿ«e% ³Ö ¶vëªö¦‘WþXÎý¯g‡‡ýþy¸µÿ6Õþ{Ë8B3ü´ˆÎœxÎDg,ijøf¼©Ç™ò¢˜q…èëGýü–@,#2Ç «„¤*´{£”;žà¶Û6,ŒMeoÍ5 uA!‰„zb5Þ}±ëÎùWUÔƒ%åŠBV²Ü°¼Òª£_’Ê'²¸›#àe^ó¦n|w„'_ƒáĽëÑòKò–Ô ªžÓ¸vñ¾9 û &÷»"’>Ùÿ×ÿxöé¿Ú—?b|¨ªÈïÉ ~œ~{Ne›?x^[v¨ã¢Ék¦è<Â[à’£"\r·‹ ÿno'À‘°n9ô‘LÝÝûF3<ÒOǃõJÜ( ¤ ‡21FPiè©–‡N…r ç}p§ó‰×&_]ÒJY§€”Šû3”×ã²cqºv¥æ훳sË•_C€}zH|“3–¸ý}qðôó>‘µ]”©£;òq¤Ü¶L¹B/M!&ÆðeÏ( ¨_NÿÄ5ŽÉ¸!8Ï™æzõ×?¨æ2Þuzή{|2 KÄÒ½kû³ù’nü€<{ùæõùéëóÁùŸÞžâÓ† Ó:B¼3ÔZ}wúú÷ç`_·'Þì*º.›.@öÔ̧ÄñÉæR°ánO°Hˆ°Î‚ÙSTlÓ˜+’Yr—¿d²•2N\S%S[ÑÔõ¬ü¶ÆµK*OÚ¥—-ÛåªZ, ‡V´_É„hHu3á²(Yß•¼:e.³µ ÿÓtNÌðêØ>^‚èl€`|?e9óÏnö} 뇇Q¢H‚zäo(eþ2XÌ7„5g…1WbF¸Ï~×D.1¿ h) â׈^¢R|k7ö)"Š{ +žÇ;›.O%„H$¡öV=.b’õ“/Áú™\É0 a̹è8ÕŸLn¥ÔNµ"X%È-GtÆ®…¤‹q”µxƒe>¹åÌeXV7w<õg6ò† Óå즲äÖ^Â-¤’Qè´œ”çsÖ9ÈÇ(¥HaM˜èõÍk@ˆ¦r® ­dFOËr=ªÄýöýžë ›Ö…xßaF?~¤Â¤©QÚÙe0­Òœ]Ö÷¤¤‚Æ쯔ÑO6Õ-õžÁeÁJêÈV²}ºC6•¶{í;ÓPz^BÅ9 LZÞÅ çÞj¸²^hù ÈA–'3†A S-ƒq`”{åú³Pñášý|Œ$ÔSØ.'ñ¦Bš…#åü2A7¾èXåh}¬rT)«Ð³k'±@ZáÿHØGu*Ѭ”W†n(0ÝUè ‘²:AÇÉ0‰¦°è ¨¯ÝO…FváÈ&Ÿ™*Ðt_\1AL‚Í1Èkac{*è¾xʽ”j8/Áè*›‘Ì^ÓK¨¯<Ñ2gŠ§À¨û¿µˆRF18¬ H\®M ÓÕÿiq1~9‡ÿŒù Éïó+‹ä Kdºj<Ú@-RÐxX™.ù–BͬrTÙÂa¶ÌhnøZ¢r)ټ̊¦â.„‚“Wdà|¶T!Jú7ÊÇò ½šáE±ÈN¼7¸^PÆwÈÆKâ“<Êñd%ÏÍyJvLù”´`Ë»TïQ¡s i3Ÿ)ÓªwéS§1ÐbO’yœC§4úUFìÍ&±*ÿ@9¼¢‹ºϯãV4Ú“ –Zlo“(ɤo§Ã`Rù˜ÃÈ@zz4Õ鯱‹;Ψ|¬Ÿ Ä„–š’ª¢47%dzüÕ¶ÜÑ,eºžOGÕuÞùÂNÓ£ËBæCXE~&›]*x. s¿tüÈŒ±ð÷qL;õáÙ9ȳ\mÑôQ³¨ü¯à¥y39vƒ~}øAï©Z‰<ÃöŠ°„R[€0GtMã«ÐÚQÈ¢Ü{¯D¤ù^ vícæYVüë ¸î:ee‘µLñÊ°ö'üz‡rÎsqæ– ï¬Ü^.1õŒ~Гh“yÀÃj §{£m«Ôê×VÇÊÐ ¯.¼‘çßx{=­ÙË–ïÛk\A£Ù†[1ÉÍz0ƒìŒ&š}ŒIÇ·3wê0u#N•çŽ®õÉ͸ C†-·cЮƒ Œ­Ñœ‘Wt$’µ¸³+T°föÜë‘™kVƤ,‰¥Ý·“Àb&=h´ÛDDszG;,BŸíàŸ’+sÈÃÏvåÓ+„·_àÐ q¨¦ÁœˆÊ&°5œx¢n`èãtû0Å /%e‹ï¸Ý­Ëq`ãQãËbÌ“öè„ò)âgí“–ó 4þa‹ÌÕçýZñÓFlÐ131^x b‰Ù –âk=w ·&Ÿ?‹ç‰CP[ºßß°áÏBÔ0·—˜4’Îí3æZâo˜ìRs]˜¡%úÛ[Zèþ×/×O_¾nßN'¥Çȹÿupx¨ßÿêmë¿­çg·G$y GE,ü°§$êí9Ÿ8ßÞ¹1 ‡Kb+ÞÿöŽ¹ÞsË+~Ù«4F?þå¿ý—ÿõßÿ-{ƾ’ÚÐýÑÖÿòþù/ÿüïÿÇýwÿòŸþãÿü§ÿ·ñÔ¤Íÿ÷ÿü¿ù§ÿû/ÿçÿÕâV镨ä÷[ù.'ÿ«Dû”ÿÎñ‘|Uþ;ϺíýÏ ÿW“}ߥl|îwòÒxÇub´¼Ø‰*àÚÅÀø”B.Å€õbõ‚¶µ¨ÝÁl9Bså ø}|ÃFINóïx“ñÀÕSÌ€‡‘¾&_I¾EKnUs¼Ä d¦…Ó‹NrEYi”¼È]ü¢óÈgža’̧2^6àe9ŠÍ]Ëa¿ û)òÁòµ€òaß`*"önÞ%ud¸ë½^Y×'Æ«”e6±L®'—›Õ° VÃÁÊ¬Ú i—’’ž¥Wâs¢wÞ­zt’·ôíI• †“†AoÒlËÄWwPY+v“?$¡R@šWºmM± ój(ëQ¹uE —øåX1Ñõ¢xs†…„P̧»ø´(õ£ ¨UŸhS[£é åa]«é`ÖoTÒ¤8Ãe¤e¾pÂÞêä0æ†`aÁÓv5VË?ž½y ô =Ó´ÊL‹È¡Æyʆf¼+kLñN¤tS*ÉãNÁ¶2XIimEÓû‚¼ˆF-Å׋o?Ñaª´ÆŒÔ±Hè$´oý˜Ö²R©ÎrK§qš¨Ê Ú´xØE! Söú`Ò=]÷42]^j·_2Ö†<=‚uãWU$ÐÉãÑ$­¤Jt¾¯A•(ôÙt]¢»U&[eRÌ( L©€yF…ŒÙXƒéƒF`¸QQ:æ±t6Î\³S1ÕT@99ÊïY *ÝØ!ÄpâYi©Œt#BU`0Ä6XꌈTv¦DÛiê*›ðu+‘­˜²Úår¢Ûh+Ûæó ¢½3ÎnØ”JÙ/W8Ö)üU¬òz¬Õ0àpÆò% 'Áè]®?ò¦¡e*²ã³H¼Pƒ›”Š>ŸÔÕƒ°[¬¿IØyô7ã€ìÅ—Q¬q­™­á†O.Ч ™ ,óx`H°6];Ìks¸1D/8¦tvàŒ‡?!r1«Zý‡vÈ•AžZNXB1ǵŠÑßP߇ \ô×â°¬^ —´]øÌ 7½ß,º<ÑRVµ,NÙå´ ¯MUnaÃB“®˜ ®?8ßês¡.?ýxýÑ—ŸìðçÑêÒkÐpzh6ÙìÖ/ ¯[»nM»gŸmmª·„ž¢íü ¬ôÇ©ávY†%̧/.È®U›qøú…üËYÎGðÌ1FžºÑÈnB9ÜSnf¿"šc^ZvñëšwìmVÑÚ·~òÊÛÿ(ÞÚØrM«.…Ÿa–(å üë®aq l \¶wœ‰íõ˜Úช¿ª¡”,&ìqÐf>aã¶åNJ$V¢a7µažž˜!p7Ž&a3Ô w8ee’–QÒüÈË¡ì`HƒGˆ2G%ÕK:©¹]! &žÒì%+¿”Œ_¼ùÆà®þ•']£ÈI“öëÈH_Ë/|í†j-hVìà©Ð|²w±´b£DiÈ·L™óU|Ñ¿èA¾¤¾óÅsÓ»(èk]]ºþÄ”"†šA„÷w˜ú¯}¹œL°ÇÒf_J˜¿ÛÎ2ž =g¼÷p’GT as2‡(hì–ª‰½¢Ø"™ñúmˉ§¹^ìÌn@MË´‘–#9Hogç¦Ñ«ÍÌ›l½¹áx\‘N V0ƒâl¸ˆõe ‡7X3z¿$ά¤¼Ñs¢¼pW[„õd™Âw˜Ù¬çÀÒôœ®Zß¡¨é¡®1]^OÝ`g—ÂÙ) 瑧Å|­ÝªæC²ÿ6z>rà¬a>Ì ©,,ã|®ºeÂl² ofižÂ2£¼b݈Ÿm‹eöc³ôèÛ1Jˆ›8óshN$kÛjDxùÚ‰Å1óÞÓ»!§7Í»ëM<8­ ›4œ–Ã)K–l%A +föÇàro1¡ƒ‚¿q! O¾”Êâ}5ò@êÉKé(}~(¾«sce ¹… ]NCšVÆþT¥L ‡i4¼M¥àçõ›óÓ5ãÒ\LxOã?|ÿü'ô§>Ù—Ýã‡Ráu°$ŒåŽ¢%æ‹Bcºì ô.`ý ½Ê}»F‡€ý /°8 ÝK AåˆÕ:dÊ ¯t 'îì]Únº’2S°s òáŒ<\´bÀ+T°mkvë¯ð&bçC&´Èm£¿yÜQ,xC°Î'ÙÅÌü‘Ç-Уééì³S!ß ÛÒ­þ9t1 Én%¥?ÿm²ÛTÍ‘tš§’F(ÃÚÃO²Idf³2‚!©zÜ·hêÞ?„̘;Íf Õ‹C@¥§‚Ó®9ÑÇ^–3­ýæåì3%øÍÜQJ Óò–ÔŠöÕb^ Ú†ŽJ ŠMì™™„ië$ ª’:²0ðô,!&zø)žšÿZÚÿ¶ 2Úc9÷#HjqæªSçzÁUt!{f¡Í5Àcƒ–"P¯O‚ž `lrÿäÍ–¡ºúÞ;±DèŸiGýßhA&G/»/ÒLˆ’5ƒ#·ôÉi9(‰äÉérÌÝ–ó{wv;õÆ^ ‡c*ì†O,˜- 1‰Z™OG£(¸1'¾ T6|Iv~Õ²¢ eþš:ÿÞ[Œ–‹[ ÕŠØž®¨Ö<ëÙ‰ÁúK :[ÖªFq…«ñ‰W+` &pkå_àÀ.4È*äLuœUx¥˜S“nÿ! ù¯Ó½IMœqoêl±utÖéè\‘Úõº<׳'†ß ê¹zw£=­Ë³“ýè¹ËIýVåÅ»"a=«…ñ‰›zСz¬Ïbt씫MX:ÒN}lš§A¸Ž4Y2¶å#ÿ†aÚ}ÉÛ®üo–i%wê#!ú*Žrlá%/½`'*úF!ÄɃµ^¸ÉùÑŸFÿ½|ɲ6× f|ƒ¯Ä¤¼i×2+Î2úhãVYH¥ÀDZžÂ]Ÿâ^öâÄdÐdM¥Ú-qoc/ΩPª'» /JÒ& xs]§¶¬FÓ›„Ÿ oÂGRîtŸ̱ˆµ,rEj†¬Æõ" ßfºpM€0cû`Wõ`åH°_¶2-‚”*‡wŽ-xuš¡» [•þfÍ7ߌ=oŽÞ@‰Õ&Ó’-'¡W„M7ý¥ÕʲGÜÞ±JZkf”4ê¬F™õñ“EàVQl¨¢ØÊ~–ìo´9û˜Ì¶ Lì–TìXæ$Qþ°Ã666°1Ò§ËIäÏ'J6Ý]VÔrLRÒ¿w¯,\DÑû`vÛ“¼s ßøDŸI¨Ç'ðåÚA¿&IÅKÃ{û@*I÷ ~5}n{'L½²Ïî{½Ä&¦Ë^ôª}SìžW‰[^w¼œçφ?u(6ºïs5Ø‘ï“F‘‹ZÒÝoÆ’4j>\G¿©§0eR óØÅj—vÜbˆþéí¦´#²-£¶>šæ‘f¸èbrRá™Ê"¥mÆž!G³—ÂEŽâ•TÜ%³Ãä÷‹@.—T\çX@P5ŽN¿¸³¾óçªõ+fˆ§¥ùÓÓ°~Ð9±aAé»XÏIŒÉ}®àf÷g£`±€¬‹‰€‹ârªf3±‘Ú,ÖénoY)Ha3Ô£ c“¤ )¬±4©&#[Ÿ‚Ô3h›V\|lê=”ê)øz´HÖ¤5‹ÏSZÄAÊk›ŠøRC‘…Aw÷ƒÉÎÝQ¢(ºI8óijŒ€ê"!@ãÀ6’ãá蹌…üj—Uå]yhDZ” K¶Æ—6›†ÖŸXÐeîy‹ÂT™²QÜ0ÕK»Ñmé“G åláM\3¬i<œ“fÌš ³hNìq°N¼ v*ÀPÅÕ¿¼… »Ç‚£$–¡§ìáƒ$ËÊÞ½} d‘¯Œ¢­Â(Ê&ƒ®_‰½yí-üˆ’"Ó.JP„ý&úqô•´äh¹Ülxz0pôÁ©0.Lƒnq¤H– $ü“øÄÞðà².¿ƒ; ƒdIe“ÇD´¾(&-þv®ƒ^YN¢ÑÄsp¬yCL–GˆÀirâ­ʉ¹jeéÑ;¥ÊçdEº¯à°‚b‰«~ÃÏáßÃú ëø’E#ñw¹‹`½ŽìPì—1êuúi|,›`¬ AÈ o´èˆ5h¤zE•fŸ4RÏKؽ(å­MzxdDËzÕ^¶îG‹E_cœä<Îü7q’¡Ç¡±›JÁMŒ¡Ç*¤$,5È"zíMæú1g̶ì­Î§Lüzs÷ÊŸÑKka)ã \¹ÒÄPï|‚xpÉÒ7gßõz àPeIÿп–NçÎ÷Øe®¡è~ˆ€´9ÝW†v’¦ ¨–Ë›O6š,ÇÔ Z†fÏ°^õçZÈClö`œÜ^Ieå#w @I¥6!ƒ'dï¨2é[%sËp’V^VB<¥­·äµ/ 8Ã[ç Ù(rÓö2f©ÌZêtß¹`ä˜ös¡§úPœÑíÎB(µ8Ö[KæãV̱}[“S¤Ø°öðçpl°-:œ_Ùúòk*+bSqs;“8£üEÏ G£±Žˆ1Ç®ÛöøªuÑcOØK?{Áð6mÑo˜?4*¬q A§näôàbT1¶bdR@è9”< 5É{£…;˜õµ°ôÞÖ`„ofâNq ¯ÍEg¥ej„`(íµ‰ý¡).`§g¸0‘½†á“2-¹ãGÍT„‚o±ðÇqÒʧ¸96̓„áWøïs—µ! ƒÕ‰-é4aÒä9pþƒM0 nƒ,¦Ý¤+ »ØŠäÍh"¹W=…;zÝi··ËUxj½†ÝûF±„žieQ}ƒ9ÉN ¯õª‰2–'wJÖkvY:ΰn7׸ô„È<-µûüêɺ’T@Uì ÓJ¶qlß… IŸ,6òØ}>AÊÓüÀ3VÊV+š¼Õšn´÷+#…8jÊ+š?FTâçêëÚÿy¼™I+üf%*m~6ËÙtÉr­zÈ¢ú7…U¬*Åee‚³ƒÖ%Îœ]m‡yz;ë=Swçhï<ýí8œ´AÚ|-N0OΈCì Œ‚ƒ¼©Ï¦Á.,`? ˆ9LÀ°I¹ç‡‰ÅÄ…¥NY«.vÊÏA¦w©8³ÛÎ$x7ƒo³xÖ’_-·ÚLgÇpÆHÕJ˜©ú­‡#Ù–×@戮Ɏ}H°&V /s5r)» ËýËŒn²ÎåÙ\ÝŠÌ&hB62Æçée]nùQ®3›¸^º7~dhcÂŒvØŸ­Ž^rÉH¢ÜÍIŸfBºkƒu·ÚÝïnˆ?ÞÕÂYcuÇþ¢s‡ò”|ñFDþ®²‰Æ[§ŒÚòëÄCщԬ¿Ë´2í-‡K ·ÐWÝK§(“Ù˜:¶Ž¥?GUî”×z9/OÛÙhºL)ª°ò”U®¢²SR…ÏUÚpÚ<=ò š­Ö°×¶6ä…p’Éí4/×7XÊ cÁ:Lu~eë–(uLlãw¶RžéËÌô‚š6ÊÅ·«I“1{ Q¦R"ˆ2’%rC uA„dA«¥D2ˆºux¬\²e¦"¹CÕ žk,'˜ºÕtüYè=:ÿfeÅŽù0hÒ¿DŸ5YoW¹õJçÜŽ¯ è*õí(X΢ŭ»a?-ó6¬ÆŠúÖµÀ§w/˜¦{Ð9vBwyã_Í‚Yݾ\cM%lÓÞw±….¸49¥W:î 7í¼á;°;ﻓÛóM0¿)“NI]-Ť\ÂyŽ‰iVN~wZªó†VEÐtª¨‘Àî`ñ¦Sf¹üäÐ&Ÿ2©ûͪÎXËix=Ì¡j1ÑHg/ÌZ¾U ¬9T5Ë)¿Ç-eeQ˜Ná9™ö›¥Û9µddz„G¬ WrŸm®Ö/€¿ên—…M_3¤çêÚ±o{,ô20—“”ÐàÈ™xdô¿7 ám\°,ÜsøÔ‰âÑ»ù6¡Á*Æð` ÈßÉÛPÕrIÊ#q6t3¯cöð»ùBülØÕŠ{!Hœò{z2°©·ã* üaéZ™5R·.›Fꌾ éx€-zRŠÚq…eÃL†5oÕófÝ Íl°Ã3ƒã ïíÖ<}­ÿè÷æYX×´9׆LÝ?°¦~\ûóMQìïS oDÍÊ`M(…VÞço]óvñƸ·U¢Þ,*ŒçÆ2Ym%36 †(¦òÆé·µ5÷‘±4®©M¶dôÎV¼ÌüNš:—TÜvÞ7eÞËVL͘éâ!‹Û©^»ˆÛ†"®ÄbÙ½t'!Tˆ‡ryï–֙ƂۃÈBŸ±5z +†&Bãd&¨-Ǭ…c.ƒ@”¶S¯¬À ñá_øßoVü§á>Íi·ã- ŽL–ˆ%l/†¿Yùç spprtô›ú£ý·Ó98>üM§û ~ïusÐ%~ãüf ?KȶF@!ú×›d´Ë{¯#÷H~X:C>߸ՈI žhz,cú‹·¯ÖB“ž-ú)ÏY{Òu¢.ÝÑ"à swt¹ía%õXLw¢÷œ'w,†ºíÍn.îÜç7ú÷»;²”°ç5*®´:{+€< â4¤‹¡âB׸!ºô?pwQYb±^¿Æ£¡b{ê-®¼= {ß\´d]s‡Êhòó N—¼JT'N’ª›K*²Y}ï…ÁT>/jüàŽý‘;i¨{5‹™ˆû }O¼+w¤&=kœ÷6Ò¶„:Ý9|ùWYK&ÎÑÁQ~÷ÝÒÝ“ÍŒ±wF€Õ`·è¼»aò¸.®÷I!3X®“Âx¾{E ö豆H#j½ü ÷~XÍœ©'ÂcÿòÒÃÒ'|®ð’1î¤ µùhøÒFJù*¸L“k~"³¼ ªÒð $¼ƒ%ºiîÝ4}_D_%XG_Tâ³f7Û²…ô™Ðiæ±ñÂi8ŸÚ€’áÒÖ™†ÜʤPõE±É`M+ :늑™ šŸ6I¬›¡FÌ–ÛËq{ž¥¥¼¹.¶+'©{·‘¾‘N¬ Ì€Gç /s€iLÑEÏé úVhæÓÉ$T¿Ž®]ôÎh½`­c?Yâ•!\¢•—üwd雓Õï×_ŸÃçOFK†Lð>}·È>{/(‘ùPwÖuõâZ𬠟Ý;O9PM¨»›uW‚:!¢Š[M¿_øQ,Eñ Šp^ æ:½“â;ø§÷É8Ò{M+ñ?¨#Wð"O Î^÷3wâÙ~ÅþzÞYÍå!vãU¸·?›èÿCÿ/ùg@«@Tâð-äÿ§oGõÿvŽŽ·þßµüü«ïÞ¼øfðöÅùÚËYxí_F{ßú¯=öXm0øöÕw§ƒA³¹“Öôg²cHùˆ(ŸvTÐÄ6Jw.çó`A;Lã: ÌBÑ,–ÃÛ+R‘ŠGÃål ß¿ôý½ۇ&rŸnèIFAðÎ÷~vÒ³©?õöáøL†ftEŒµoüÅÅî“;3²÷û ×ý¿%‚¸Ûo³€Cç×KÒê®ðÞàoÔÊ;¯:ŸÍȶƒ¬i#oàÞ¸þ\WbSºª1á âÎÎgDÊÛÄνô¯–hD9¿Ò¿~¥ö/ù­Írö;?Ì{½s‚z¯÷½]ã0n´pýÐÐsk80Œ=bŒhÉÁOvâ†Ô\ÛðÉ&Y.YÙ§#Òë½¢UXØ3Z%®›xÑàj ÝÉ'd)Ý®:kÒÿŒéoû£»$æ„7c- +æèÿƒÎщvþ×9::Üêÿuü@9P6×ñìï-CoÁë†áû`1{¼ñ5´@wÇרÛôË“£=¢Ñø7÷½'wü«ûÝæVˆü£d `åªFô­äÿø qþ|¸µÿÖòÃ+Ó™?'Ïê1yÿíû=ð‹Ì݈!˜VkìMÈ»›%S´ hA8êáÐGN¨úë=Ý ‚mµ‹->/ù Uî[DÝ°ßþa¿*[bòŠþÂK2 ÌÍEãå›×积Ïçz{ÚèS/;ŸO|jìS“Žy›ˆ.Ú£@µ €Ý4DÙì0»h/I§æÎÇ#ÿÜý?¸tßU¸Ì“ÿgÚúßyÖ}¶•ÿuÊ?ì vDò3Êô 뎟2Îøƒß›Â7øœm¢þ8ùC‹•K”ÒJxTÁ ñg~ä»ÿop+>Œz.ióg¬ÜV|ð;ò iHþIð_Í#ƒÛ~¨€fò[²#" 2#[+ïƒ7ÒÇ<£ãsŽúìh潇þÚãå<%Y)ÀÛæã2g+žŇÓÏ¿ŒÁhÖ¨È?l*a´ðˆW¡'(Oþ‰èëòßév¶ò¿Ž&ÄdâÏؼï$¤Ù‚X×” 'þçÿ=öÓã–‚{d=e«)z;‚¹7Û‹?n9Å°ÑT¼ð¿£±×9À5Ù¸"o-÷Öÿø¡:ã?_þ»'ÇÏtûÿàp»ÿ_ËÏç'컳óÄùÕߥ ˆˆãaš¨šÌϦX8 Ü伌ß.árfN»{ðm[êoGnÚ%¦Þyï‡^{tEÌuðvûÂ~$¹-´!Èc¼/Ócš‡it#s£·§p¾ÀiÈÏ9"rSÒW¿)uM¶¥úÖ:ºöÜ13šVìɼy$ŽúªèØß0ª]ן8/WX‘ô|»hÅì.gïfÁû™Ç„;ÄBp#ïêB‰µ‰‡´mR§—Âò¶ŸÜ»{ÇyBXèi07Lé­D^Öºñ‡óó·ƒ/_ž¾=GãêBc»ò†ñf6nKxÝD‚Eÿþ©òŒ2Ïýn\[¼¤‡Ë<ì§ßÓ¹;ŠØì|ÊN¶ï-&Õùà§ÓÎ^½yìaý¯sn‰¡¿GWuŽõò¿t©FE@~žëâ¯}ÀLã ®ô_ôð_4ƒ)r¦+Ðo“(ü{p©c"´Ýóç23ÆŸ%? }˜•›Ï;®wÜ<¢ÇF'#2™Ç£®ë^vN.>ï|Öýüà¤;ÎS3ìíÐ{†¤/gï Ý9jwøÖ–(IÿÆ %߃㠗þd,<PAÜ'ß}ùÜé¶;mY„±ùèÄwöa»«¾û0ૃöqü ŽwÅòÓ§T)ËO¦Pí€GRù‹h²OàÓߟ~/Ññ:Šæ!¡$?“n‹«}• ¶ÎÞQ»Û>æ øÏ&ÿÇ—ÜgüÅŽ<ë´ŸµùYüv Û5pE@‹ã˜¦Ñ5ÙÔ¡{é±ñcòßö‘hô‹?» XçìS÷ƒLŸâ6ÎSÜåØ GD¹³(D@oÁº>ˆ»Ä¼,—¾éH“•„ͺ³Gæ‘O×(ð#.eì1šçƒÃº36QÀµ€ÉûówÃìÓ{ÌY’³}HÑÙ#SÇŒ‰”`_Ò í´?ãßÅsx,=”X»_wåçÈÖÀÓŒu(GwÚ'5‰™¡áQÌc‚ù”¶ÈæÐT@ È‰ ¼B1 ë˜óR'ž9y ¸ AÇ2…õäÖ  ³Úp›Èƒi*µ&ŸI~ûÝ‹óoßüðýÈ3‘ßoNßž¾þæôõËW§ð•×';;_ÿøú›ïN¿qþþÕù g2=í“­gbû³ýÙþ<’Ÿÿ_ÿÿ÷üµ•&checksums.yaml.gz0000444000000000000000000000041512700012423014573 0ustar00wheelwheel00000000000000‹We9V0 Dûœ"O«-§££ç²*^*NI Š‘þH£Ûívy{Åûåzý¬‡§?üåãû~EÒe˱<‡õ°!=æ’\[&l‹Ã=™‡=9ˆ îÄcóÀnNR–VQz”øݪHÿö‚ò± :6æ[ \DÁaKÍ\Ì3¶&x-‚È€$iAl%[v‘ôétL]áÍÂÈ2Wˆ¦ŸÛ­P2·™ÏŠS}ÂòÉ‹ÿæI³`ÓÂ.“U¡ŽDH£W±”£v‡Ž…ŽQk^pŽ8h¶—Y·Â™¢³¡ Î'ÔTVTWY‰²y&– çâòËÜW9$¢grape-0.16.2/CONTRIBUTING.md0000644000004100000410000000670512706307016015171 0ustar www-datawww-dataContributing to Grape ===================== Grape is work of [hundreds of contributors](https://github.com/ruby-grape/grape/graphs/contributors). You're encouraged to submit [pull requests](https://github.com/ruby-grape/grape/pulls), [propose features and discuss issues](https://github.com/ruby-grape/grape/issues). When in doubt, ask a question in the [Grape Google Group](http://groups.google.com/group/ruby-grape). #### Fork the Project Fork the [project on Github](https://github.com/ruby-grape/grape) and check out your copy. ``` git clone https://github.com/contributor/grape.git cd grape git remote add upstream https://github.com/ruby-grape/grape.git ``` #### Create a Topic Branch Make sure your fork is up-to-date and create a topic branch for your feature or bug fix. ``` git checkout master git pull upstream master git checkout -b my-feature-branch ``` #### Bundle Install and Test Ensure that you can build the project and run tests. ``` bundle install bundle exec rake ``` Run tests against all supported versions of Rails. ``` appraisal install appraisal rake spec ``` #### Write Tests Try to write a test that reproduces the problem you're trying to fix or describes a feature that you want to build. Add to [spec/grape](spec/grape). We definitely appreciate pull requests that highlight or reproduce a problem, even without a fix. #### Write Code Implement your feature or bug fix. Ruby style is enforced with [Rubocop](https://github.com/bbatsov/rubocop), run `bundle exec rubocop` and fix any style issues highlighted. Make sure that `bundle exec rake` completes without errors. #### Write Documentation Document any external behavior in the [README](README.md). #### Update Changelog Add a line to [CHANGELOG](CHANGELOG.md) under *Next Release*. Make it look like every other line, including your name and link to your Github account. #### Commit Changes Make sure git knows your name and email address: ``` git config --global user.name "Your Name" git config --global user.email "contributor@example.com" ``` Writing good commit logs is important. A commit log should describe what changed and why. ``` git add ... git commit ``` #### Push ``` git push origin my-feature-branch ``` #### Make a Pull Request Go to https://github.com/contributor/grape and select your feature branch. Click the 'Pull Request' button and fill out the form. Pull requests are usually reviewed within a few days. #### Rebase If you've been working on a change for a while, rebase with upstream/master. ``` git fetch upstream git rebase upstream/master git push origin my-feature-branch -f ``` #### Update CHANGELOG Again Update the [CHANGELOG](CHANGELOG.md) with the pull request number. A typical entry looks as follows. ``` * [#123](https://github.com/ruby-grape/grape/pull/123): Reticulated splines - [@contributor](https://github.com/contributor). ``` Amend your previous commit and force push the changes. ``` git commit --amend git push origin my-feature-branch -f ``` #### Check on Your Pull Request Go back to your pull request after a few minutes and see whether it passed muster with Travis-CI. Everything should look green, otherwise fix issues and amend your commit as described above. #### Be Patient It's likely that your change will not be merged and that the nitpicky maintainers will ask you to do more, or fix seemingly benign problems. Hang on there! #### Thank You Please do know that we really appreciate and value your time and work. We love you, really. grape-0.16.2/LICENSE0000644000004100000410000000207212706307016013736 0ustar www-datawww-dataCopyright (c) 2010-2015 Michael Bleigh and Intridea, Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. grape-0.16.2/RELEASING.md0000644000004100000410000000573412706307016014574 0ustar www-datawww-dataReleasing Grape =============== There're no particular rules about when to release Grape. Release bug fixes frequently, features not so frequently and breaking API changes rarely. ### Release Run tests, check that all tests succeed locally. ``` bundle install rake ``` Check that the last build succeeded in [Travis CI](https://travis-ci.org/ruby-grape/grape) for all supported platforms. Those with r/w permissions to the [master Grape repository](https://github.com/ruby-grape/grape) generally have large Grape-based projects. Point one to Grape HEAD and run all your API tests to catch any obvious regressions. ``` gem grape, github: 'ruby-grape/grape' ``` Increment the version, modify [lib/grape/version.rb](lib/grape/version.rb). * Increment the third number if the release has bug fixes and/or very minor features, only (eg. change `0.5.1` to `0.5.2`). * Increment the second number if the release contains major features or breaking API changes (eg. change `0.5.1` to `0.6.0`). Modify the "Stable Release" section in [README.md](README.md). Change the text to reflect that this is going to be the documentation for a stable release. Remove references to the previous release of Grape. Keep the file open, you'll have to undo this change after the release. ``` ## Stable Release You're reading the documentation for the stable release of Grape, 0.6.0. ``` Change "Next Release" in [CHANGELOG.md](CHANGELOG.md) to the new version. ``` 0.6.0 (9/16/2013) ================= ``` Remove the line with "Your contribution here.", since there will be no more contributions to this release. Commit your changes. ``` git add README.md CHANGELOG.md lib/grape/version.rb git commit -m "Preparing for release, 0.6.0." git push origin master ``` Release. ``` $ rake release grape 0.6.0 built to pkg/grape-0.6.0.gem. Tagged v0.6.0. Pushed git commits and tags. Pushed grape 0.6.0 to rubygems.org. ``` ### Prepare for the Next Version Modify the "Stable Release" section in [README.md](README.md). Change the text to reflect that this is going to be the next release. ``` ## Stable Release You're reading the documentation for the next release of Grape, which should be 0.6.1. The current stable release is [0.6.0](https://github.com/ruby-grape/grape/blob/v0.6.0/README.md). ``` Add the next release to [CHANGELOG.md](CHANGELOG.md). ``` Next Release ============ * Your contribution here. ``` Bump the minor version in lib/grape/version.rb. ```ruby module Grape VERSION = '0.6.1' end ``` Comit your changes. ``` git add CHANGELOG.md README.md lib/grape/version.rb git commit -m "Preparing for next development iteration, 0.6.1." git push origin master ``` ### Make an Announcement Make an announcement on the [ruby-grape@googlegroups.com](mailto:ruby-grape@googlegroups.com) mailing list. The general format is as follows. ``` Grape 0.6.0 has been released. There were 8 contributors to this release, not counting documentation. Please note the breaking API change in ... [copy/paste CHANGELOG here] ``` grape-0.16.2/Appraisals0000644000004100000410000000036512706307016014756 0ustar www-datawww-dataappraise 'rails-3' do gem 'rails', '3.2.19' gem 'rack-cache', '<= 1.2' # Pin as next rack-cache version (1.3) removes Ruby1.9 support end appraise 'rails-4' do gem 'rails', '4.1.6' end appraise 'rack-1.5.2' do gem 'rack', '1.5.2' end grape-0.16.2/CHANGELOG.md0000644000004100000410000014715312706307016014554 0ustar www-datawww-data0.16.2 (4/12/2016) ================== #### Features * [#1348](https://github.com/ruby-grape/grape/pull/1348): Fix global functions polluting Grape::API scope - [@dblock](https://github.com/dblock). * [#1357](https://github.com/ruby-grape/grape/pull/1357): Expose Route#options - [@namusyaka](https://github.com/namusyaka). #### Fixes * [#1357](https://github.com/ruby-grape/grape/pull/1357): Don't include fixed named captures as route params - [@namusyaka](https://github.com/namusyaka). * [#1359](https://github.com/ruby-grape/grape/pull/1359): Avoid evaluating the same route twice - [@namusyaka](https://github.com/namusyaka), [@dblock](https://github.com/dblock). * [#1361](https://github.com/ruby-grape/grape/pull/1361): Return 405 correctly even if version is using as header and wrong request method - [@namusyaka](https://github.com/namusyaka), [@dblock](https://github.com/dblock). 0.16.1 (4/3/2016) ================= #### Features * [#1276](https://github.com/ruby-grape/grape/pull/1276): Replace rack-mount with new router - [@namusyaka](https://github.com/namusyaka). * [#1321](https://github.com/ruby-grape/grape/pull/1321): Serve files without using FileStreamer-like object - [@lfidnl](https://github.com/lfidnl). * [#1339](https://github.com/ruby-grape/grape/pull/1339): Implement Grape::API.recognize_path - [@namusyaka](https://github.com/namusyaka). #### Fixes * [#1325](https://github.com/ruby-grape/grape/pull/1325): Params: Fix coerce_with helper with Array types - [@ngonzalez](https://github.com/ngonzalez). * [#1326](https://github.com/ruby-grape/grape/pull/1326): Fix wrong behavior for OPTIONS and HEAD requests with catch-all - [@ekampp](https://github.com/ekampp), [@namusyaka](https://github.com/namusyaka). * [#1330](https://github.com/ruby-grape/grape/pull/1330): Add `register` keyword for adding customized parsers and formatters - [@namusyaka](https://github.com/namusyaka). * [#1336](https://github.com/ruby-grape/grape/pull/1336): Do not modify Hash argument to `error!` - [@tjwp](https://github.com/tjwp). 0.15.0 (3/8/2016) ================= #### Features * [#1227](https://github.com/ruby-grape/grape/pull/1227): Store `message_key` on `Grape::Exceptions::Validation` - [@stjhimy](https://github.com/sthimy). * [#1232](https://github.com/ruby-grape/grape/pull/1232): Helpers are now available inside `rescue_from` - [@namusyaka](https://github.com/namusyaka). * [#1237](https://github.com/ruby-grape/grape/pull/1237): Allow multiple parameters in `given`, which behaves as if the scopes were nested in the inputted order - [@ochagata](https://github.com/ochagata). * [#1238](https://github.com/ruby-grape/grape/pull/1238): Call `after` of middleware on error - [@namusyaka](https://github.com/namusyaka). * [#1243](https://github.com/ruby-grape/grape/pull/1243): Add `header` support for middleware - [@namusyaka](https://github.com/namusyaka). * [#1252](https://github.com/ruby-grape/grape/pull/1252): Allow default to be a subset or equal to allowed values without raising IncompatibleOptionValues - [@jeradphelps](https://github.com/jeradphelps). * [#1255](https://github.com/ruby-grape/grape/pull/1255): Allow param type definition in `route_param` - [@namusyaka](https://github.com/namusyaka). * [#1257](https://github.com/ruby-grape/grape/pull/1257): Allow Proc, Symbol or String in `rescue_from with: ...` - [@namusyaka](https://github.com/namusyaka). * [#1280](https://github.com/ruby-grape/grape/pull/1280): Support `Rack::Sendfile` middleware - [@lfidnl](https://github.com/lfidnl). * [#1285](https://github.com/ruby-grape/grape/pull/1285): Add a warning for errors appearing in `after` callbacks - [@gregormelhorn](https://github.com/gregormelhorn). * [#1295](https://github.com/ruby-grape/grape/pull/1295): Add custom validation messages for parameter exceptions - [@railsmith](https://github.com/railsmith). #### Fixes * [#1216](https://github.com/ruby-grape/grape/pull/1142): Fix JSON error response when calling `error!` with non-Strings - [@jrforrest](https://github.com/jrforrest). * [#1225](https://github.com/ruby-grape/grape/pull/1225): Fix `given` with nested params not returning correct declared params - [@JanStevens](https://github.com/JanStevens). * [#1249](https://github.com/ruby-grape/grape/pull/1249): Don't fail even if invalid type value is passed to default validator - [@namusyaka](https://github.com/namusyaka). * [#1266](https://github.com/ruby-grape/grape/pull/1266): Fix `Allow` header including `OPTIONS` when `do_not_route_options!` is active - [@arempe93](https://github.com/arempe93). * [#1270](https://github.com/ruby-grape/grape/pull/1270): Fix `param` versioning with a custom parameter - [@wshatch](https://github.com/wshatch). * [#1282](https://github.com/ruby-grape/grape/pull/1282): Fix specs circular dependency - [@304](https://github.com/304). * [#1283](https://github.com/ruby-grape/grape/pull/1283): Fix 500 error for xml format when method is not allowed - [@304](https://github.com/304). * [#1197](https://github.com/ruby-grape/grape/pull/1290): Fix using JSON and Array[JSON] as groups when parameter is optional - [@lukeivers](https://github.com/lukeivers). 0.14.0 (12/07/2015) ================= #### Features * [#1218](https://github.com/ruby-grape/grape/pull/1218): Provide array index context in errors - [@towanda](https://github.com/towanda). * [#1196](https://github.com/ruby-grape/grape/pull/1196): Allow multiple `before_each` blocks - [@huynhquancam](https://github.com/huynhquancam). * [#1190](https://github.com/ruby-grape/grape/pull/1190): Bypass formatting for statuses with no entity-body - [@tylerdooling](https://github.com/tylerdooling). * [#1188](https://github.com/ruby-grape/grape/pull/1188): Allow parameters with more than one type - [@dslh](https://github.com/dslh). * [#1179](https://github.com/ruby-grape/grape/pull/1179): Allow all RFC6838 valid characters in header vendor - [@suan](https://github.com/suan). * [#1170](https://github.com/ruby-grape/grape/pull/1170): Allow dashes and periods in header vendor - [@suan](https://github.com/suan). * [#1167](https://github.com/ruby-grape/grape/pull/1167): Convenience wrapper `type: File` for validating multipart file parameters - [@dslh](https://github.com/dslh). * [#1167](https://github.com/ruby-grape/grape/pull/1167): Refactor and extend coercion and type validation system - [@dslh](https://github.com/dslh). * [#1163](https://github.com/ruby-grape/grape/pull/1163): First-class `JSON` parameter type - [@dslh](https://github.com/dslh). * [#1161](https://github.com/ruby-grape/grape/pull/1161): Custom parameter coercion using `coerce_with` - [@dslh](https://github.com/dslh). #### Fixes * [#1194](https://github.com/ruby-grape/grape/pull/1194): Redirect as plain text with message - [@tylerdooling](https://github.com/tylerdooling). * [#1185](https://github.com/ruby-grape/grape/pull/1185): Use formatters for custom vendored content types - [@tylerdooling](https://github.com/tylerdooling). * [#1156](https://github.com/ruby-grape/grape/pull/1156): Fixed `no implicit conversion of Symbol into Integer` with nested `values` validation - [@quickpay](https://github.com/quickpay). * [#1153](https://github.com/ruby-grape/grape/pull/1153): Fixes boolean declaration in an external file - [@towanda](https://github.com/towanda). * [#1142](https://github.com/ruby-grape/grape/pull/1142): Makes #declared unavailable to before filters - [@jrforrest](https://github.com/jrforrest). * [#1114](https://github.com/ruby-grape/grape/pull/1114): Fix regression which broke identical endpoints with different versions - [@suan](https://github.com/suan). * [#1109](https://github.com/ruby-grape/grape/pull/1109): Memoize Virtus attribute and fix memory leak - [@marshall-lee](https://github.com/marshall-lee). * [#1101](https://github.com/ruby-grape/grape/pull/1101): Fix: Incorrect media-type `Accept` header now correctly returns 406 with `strict: true` - [@elliotlarson](https://github.com/elliotlarson). * [#1108](https://github.com/ruby-grape/grape/pull/1039): Raise a warning when `desc` is called with options hash and block - [@rngtng](https://github.com/rngtng). 0.13.0 (8/10/2015) ================== #### Features * [#1039](https://github.com/ruby-grape/grape/pull/1039): Added support for custom parameter types - [@rnubel](https://github.com/rnubel). * [#1047](https://github.com/ruby-grape/grape/pull/1047): Adds `given` to DSL::Parameters, allowing for dependent params - [@rnubel](https://github.com/rnubel). * [#1064](https://github.com/ruby-grape/grape/pull/1064): Add public `Grape::Exception::ValidationErrors#full_messages` - [@romanlehnert](https://github.com/romanlehnert). * [#1079](https://github.com/ruby-grape/grape/pull/1079): Added `stream` method to take advantage of `Rack::Chunked` [@zbelzer](https://github.com/zbelzer). * [#1086](https://github.com/ruby-grape/grape/pull/1086): Added `ActiveSupport::Notifications` instrumentation - [@wagenet](https://github.com/wagenet). #### Fixes * [#1062](https://github.com/ruby-grape/grape/issues/1062): Fix: `Grape::Exceptions::ValidationErrors` will include headers set by `header` - [@yairgo](https://github.com/yairgo). * [#1038](https://github.com/ruby-grape/grape/pull/1038): Avoid dup-ing the `String` class when used in inherited params - [@rnubel](https://github.com/rnubel). * [#1042](https://github.com/ruby-grape/grape/issues/1042): Fix coercion of complex arrays - [@dim](https://github.com/dim). * [#1045](https://github.com/ruby-grape/grape/pull/1045): Do not convert `Rack::Response` to `Rack::Response` in middleware - [@dmitry](https://github.com/dmitry). * [#1048](https://github.com/ruby-grape/grape/pull/1048): Only dup `InheritableValues`, remove support for `deep_dup` - [@toddmazierski](https://github.com/toddmazierski/). * [#1052](https://github.com/ruby-grape/grape/pull/1052): Reset `description[:params]` when resetting validations - [@marshall-lee](https://github.com/marshall-lee). * [#1088](https://github.com/ruby-grape/grape/pull/1088): Support ActiveSupport 3.x by explicitly requiring `Hash#except` - [@wagenet](https://github.com/wagenet). * [#1096](https://github.com/ruby-grape/grape/pull/1096): Fix coercion on booleans - [@towanda](https://github.com/towanda). 0.12.0 (6/18/2015) ================== #### Features * [#995](https://github.com/ruby-grape/grape/issues/995): Added support for coercion to Set or Set[Other] - [@jordansexton](https://github.com/jordansexton) [@u2](https://github.com/u2). * [#980](https://github.com/ruby-grape/grape/issues/980): Grape is now eager-loaded - [@u2](https://github.com/u2). * [#956](https://github.com/ruby-grape/grape/issues/956): Support `present` with `Grape::Presenters::Presenter` - [@u2](https://github.com/u2). * [#974](https://github.com/ruby-grape/grape/pull/974): Added `error!` to `rescue_from` blocks - [@whatasunnyday](https://github.com/whatasunnyday). * [#950](https://github.com/ruby-grape/grape/pull/950): Status method can now accept one of Rack::Utils status code symbols (:ok, :found, :bad_request, etc.) - [@dabrorius](https://github.com/dabrorius). * [#952](https://github.com/ruby-grape/grape/pull/952): Status method now raises error when called with invalid status code - [@dabrorius](https://github.com/dabrorius). * [#957](https://github.com/ruby-grape/grape/pull/957): Regexp validator now supports `allow_blank`, `nil` value behavior changed - [@calfzhou](https://giihub.com/calfzhou). * [#962](https://github.com/ruby-grape/grape/pull/962): The `default` attribute with `false` value is documented now - [@ajvondrak](https://github.com/ajvondrak). * [#1026](https://github.com/ruby-grape/grape/pull/1026): Added `file` method, explicitly setting a file-like response object - [@dblock](https://github.com/dblock). #### Fixes * [#994](https://github.com/ruby-grape/grape/pull/994): Fixed optional Array params default to Hash - [@u2](https://github.com/u2). * [#988](https://github.com/ruby-grape/grape/pull/988): Fixed duplicate identical endpoints - [@u2](https://github.com/u2). * [#936](https://github.com/ruby-grape/grape/pull/936): Fixed default params processing for optional groups - [@dm1try](https://github.com/dm1try). * [#942](https://github.com/ruby-grape/grape/pull/942): Fixed forced presence for optional params when based on a reused entity that was also required in another context - [@croeck](https://github.com/croeck). * [#1001](https://github.com/ruby-grape/grape/pull/1001): Fixed calling endpoint with specified format with format in its path - [@hodak](https://github.com/hodak). * [#1005](https://github.com/ruby-grape/grape/pull/1005): Fixed the Grape::Middleware::Globals - [@urkle](https://github.com/urkle). * [#1012](https://github.com/ruby-grape/grape/pull/1012): Fixed `allow_blank: false` with a Boolean value of `false` - [@mfunaro](https://github.com/mfunaro). * [#1023](https://github.com/ruby-grape/grape/issues/1023): Fixes unexpected behavior with `present` and an object that responds to `merge` but isn't a Hash - [@dblock](https://github.com/dblock). * [#1017](https://github.com/ruby-grape/grape/pull/1017): Fixed `undefined method stringify_keys` with nested mutual exclusive params - [@quickpay](https://github.com/quickpay). 0.11.0 (2/23/2015) ================== * [#925](https://github.com/ruby-grape/grape/pull/925): Fixed `toplevel constant DateTime referenced by Virtus::Attribute::DateTime` - [@u2](https://github.com/u2). * [#916](https://github.com/ruby-grape/grape/pull/916): Added `DateTime/Date/Numeric/Boolean` type support `allow_blank` - [@u2](https://github.com/u2). * [#871](https://github.com/ruby-grape/grape/pull/871): Fixed `Grape::Middleware::Base#response` - [@galathius](https://github.com/galathius). * [#559](https://github.com/ruby-grape/grape/issues/559): Added support for Rack 1.6.0, which parses requests larger than 128KB - [@myitcv](https://github.com/myitcv). * [#876](https://github.com/ruby-grape/grape/pull/876): Call to `declared(params)` now returns a `Hashie::Mash` - [@rodzyn](https://github.com/rodzyn). * [#879](https://github.com/ruby-grape/grape/pull/879): The `route_info` value is no longer included in `params` Hash - [@rodzyn](https://github.com/rodzyn). * [#881](https://github.com/ruby-grape/grape/issues/881): Fixed `Grape::Validations::ValuesValidator` support for `Range` type - [@ajvondrak](https://github.com/ajvondrak). * [#901](https://github.com/ruby-grape/grape/pull/901): Fix: callbacks defined in a version block are only called for the routes defined in that block - [@kushkella](https://github.com/kushkella). * [#886](https://github.com/ruby-grape/grape/pull/886): Group of parameters made to require an explicit type of Hash or Array - [@jrichter1](https://github.com/jrichter1). * [#912](https://github.com/ruby-grape/grape/pull/912): Extended the `:using` feature for param documentation to `optional` fields - [@croeck](https://github.com/croeck). * [#906](https://github.com/ruby-grape/grape/pull/906): Fix: invalid body parse errors are not rescued by handlers - [@croeck](https://github.com/croeck). * [#913](https://github.com/ruby-grape/grape/pull/913): Fix: Invalid accept headers are not processed by rescue handlers - [@croeck](https://github.com/croeck). * [#913](https://github.com/ruby-grape/grape/pull/913): Fix: Invalid accept headers cause internal processing errors (500) when http_codes are defined - [@croeck](https://github.com/croeck). * [#917](https://github.com/ruby-grape/grape/pull/917): Use HTTPS for rubygems.org - [@O-I](https://github.com/O-I). 0.10.1 (12/28/2014) =================== * [#868](https://github.com/ruby-grape/grape/pull/868), [#862](https://github.com/ruby-grape/grape/pull/862), [#861](https://github.com/ruby-grape/grape/pull/861): Fixed `version`, `prefix`, and other settings being overridden or changing scope when mounting API - [@yesmeck](https://github.com/yesmeck). * [#864](https://github.com/ruby-grape/grape/pull/864): Fixed `declared(params, include_missing: false)` now returning attributes with `nil` and `false` values - [@ppadron](https://github.com/ppadron). 0.10.0 (12/19/2014) =================== * [#803](https://github.com/ruby-grape/grape/pull/803), [#820](https://github.com/ruby-grape/grape/pull/820): Added `all_or_none_of` parameter validator - [@loveltyoic](https://github.com/loveltyoic), [@natecj](https://github.com/natecj). * [#774](https://github.com/ruby-grape/grape/pull/774): Extended `mutually_exclusive`, `exactly_one_of`, `at_least_one_of` to work inside any kind of group: `requires` or `optional`, `Hash` or `Array` - [@ShPakvel](https://github.com/ShPakvel). * [#743](https://github.com/ruby-grape/grape/pull/743): Added `allow_blank` parameter validator to validate non-empty strings - [@elado](https://github.com/elado). * [#745](https://github.com/ruby-grape/grape/pull/745): Removed `atom+xml`, `rss+xml`, and `jsonapi` content-types - [@akabraham](https://github.com/akabraham). * [#745](https://github.com/ruby-grape/grape/pull/745): Added `:binary, application/octet-stream` content-type - [@akabraham](https://github.com/akabraham). * [#757](https://github.com/ruby-grape/grape/pull/757): Changed `desc` can now be used with a block syntax - [@dspaeth-faber](https://github.com/dspaeth-faber). * [#779](https://github.com/ruby-grape/grape/pull/779): Fixed using `values` with a `default` proc - [@ShPakvel](https://github.com/ShPakvel). * [#799](https://github.com/ruby-grape/grape/pull/799): Fixed custom validators with required `Hash`, `Array` types - [@bwalex](https://github.com/bwalex). * [#784](https://github.com/ruby-grape/grape/pull/784): Fixed `present` to not overwrite the previously added contents of the response body whebn called more than once - [@mfunaro](https://github.com/mfunaro). * [#809](https://github.com/ruby-grape/grape/pull/809): Removed automatic `(.:format)` suffix on paths if you're using only one format (e.g., with `format :json`, `/path` will respond with JSON but `/path.xml` will be a 404) - [@ajvondrak](https://github.com/ajvondrak). * [#816](https://github.com/ruby-grape/grape/pull/816): Added ability to filter out missing params if params is a nested hash with `declared(params, include_missing: false)` - [@georgimitev](https://github.com/georgimitev). * [#819](https://github.com/ruby-grape/grape/pull/819): Allowed both `desc` and `description` in the params DSL - [@mzikherman](https://github.com/mzikherman). * [#821](https://github.com/ruby-grape/grape/pull/821): Fixed passing string value when hash is expected in params - [@rebelact](https://github.com/rebelact). * [#824](https://github.com/ruby-grape/grape/pull/824): Validate array params against list of acceptable values - [@dnd](https://github.com/dnd). * [#813](https://github.com/ruby-grape/grape/pull/813): Routing methods dsl refactored to get rid of explicit `paths` parameter - [@AlexYankee](https://github.com/AlexYankee). * [#826](https://github.com/ruby-grape/grape/pull/826): Find `coerce_type` for `Array` when not specified - [@manovotn](https://github.com/manovotn). * [#645](https://github.com/ruby-grape/grape/issues/645): Invoking `body false` will return `204 No Content` - [@dblock](https://github.com/dblock). * [#801](https://github.com/ruby-grape/grape/issues/801): Only evaluate permitted parameter `values` and `default` lazily on each request when declared as a proc - [@dblock](https://github.com/dblock). * [#679](https://github.com/ruby-grape/grape/issues/679): Fixed `OPTIONS` method returning 404 when combined with `prefix`- [@dblock](https://github.com/dblock). * [#679](https://github.com/ruby-grape/grape/issues/679): Fixed unsupported methods returning 404 instead of 405 when combined with `prefix`- [@dblock](https://github.com/dblock). 0.9.0 (8/27/2014) ================= #### Features * [#691](https://github.com/ruby-grape/grape/issues/691): Added `at_least_one_of` parameter validator - [@dblock](https://github.com/dblock). * [#698](https://github.com/ruby-grape/grape/pull/698): `error!` sets `status` for `Endpoint` too - [@dspaeth-faber](https://github.com/dspaeth-faber). * [#703](https://github.com/ruby-grape/grape/pull/703): Added support for Auth-Middleware extension - [@dspaeth-faber](https://github.com/dspaeth-faber). * [#703](https://github.com/ruby-grape/grape/pull/703): Removed `Grape::Middleware::Auth::Basic` - [@dspaeth-faber](https://github.com/dspaeth-faber). * [#703](https://github.com/ruby-grape/grape/pull/703): Removed `Grape::Middleware::Auth::Digest` - [@dspaeth-faber](https://github.com/dspaeth-faber). * [#703](https://github.com/ruby-grape/grape/pull/703): Removed `Grape::Middleware::Auth::OAuth2` - [@dspaeth-faber](https://github.com/dspaeth-faber). * [#719](https://github.com/ruby-grape/grape/pull/719): Allow passing options hash to a custom validator - [@elado](https://github.com/elado). * [#716](https://github.com/ruby-grape/grape/pull/716): Calling `content-type` will now return the current content-type - [@dblock](https://github.com/dblock). * [#705](https://github.com/ruby-grape/grape/pull/705): Errors can now be presented with a `Grape::Entity` class - [@dspaeth-faber](https://github.com/dspaeth-faber). #### Fixes * [#687](https://github.com/ruby-grape/grape/pull/687): Fix: `mutually_exclusive` and `exactly_one_of` validation error messages now label parameters as strings, consistently with `requires` and `optional` - [@dblock](https://github.com/dblock). 0.8.0 (7/10/2014) ================= #### Features * [#639](https://github.com/ruby-grape/grape/pull/639): Added support for blocks with reusable params - [@mibon](https://github.com/mibon). * [#637](https://github.com/ruby-grape/grape/pull/637): Added support for `exactly_one_of` parameter validation - [@Morred](https://github.com/Morred). * [#626](https://github.com/ruby-grape/grape/pull/626): Added support for `mutually_exclusive` parameters - [@oliverbarnes](https://github.com/oliverbarnes). * [#617](https://github.com/ruby-grape/grape/pull/617): Running tests on Ruby 2.1.1, Rubinius 2.1 and 2.2, Ruby and JRuby HEAD - [@dblock](https://github.com/dblock). * [#397](https://github.com/ruby-grape/grape/pull/397): Adds `Grape::Endpoint.before_each` to allow easy helper stubbing - [@mbleigh](https://github.com/mbleigh). * [#673](https://github.com/ruby-grape/grape/pull/673): Avoid requiring non-existent fields when using Grape::Entity documentation - [@qqshfox](https://github.com/qqshfox). #### Fixes * [#671](https://github.com/ruby-grape/grape/pull/671): Allow required param with predefined set of values to be nil inside optional group - [@dm1try](https://github.com/dm1try). * [#651](https://github.com/ruby-grape/grape/pull/651): The `rescue_from` keyword now properly defaults to rescuing subclasses of exceptions - [@xevix](https://github.com/xevix). * [#614](https://github.com/ruby-grape/grape/pull/614): Params with `nil` value are now refused by `RegexpValidator` - [@dm1try](https://github.com/dm1try). * [#494](https://github.com/ruby-grape/grape/issues/494): Fixed performance issue with requests carrying a large payload - [@dblock](https://github.com/dblock). * [#619](https://github.com/ruby-grape/grape/pull/619): Convert specs to RSpec 3 syntax with Transpec - [@danielspector](https://github.com/danielspector). * [#632](https://github.com/ruby-grape/grape/pull/632): `Grape::Endpoint#present` causes ActiveRecord to make an extra query during entity's detection - [@fixme](https://github.com/fixme). 0.7.0 (4/2/2014) ================= #### Features * [#558](https://github.com/ruby-grape/grape/pull/558): Support lambda-based values for params - [@wpschallenger](https://github.com/wpschallenger). * [#510](https://github.com/ruby-grape/grape/pull/510): Support lambda-based default values for params - [@myitcv](https://github.com/myitcv). * [#511](https://github.com/ruby-grape/grape/pull/511): Added `required` option for OAuth2 middleware - [@bcm](https://github.com/bcm). * [#520](https://github.com/ruby-grape/grape/pull/520): Use `default_error_status` to specify the default status code returned from `error!` - [@salimane](https://github.com/salimane). * [#525](https://github.com/ruby-grape/grape/pull/525): The default status code returned from `error!` has been changed from 403 to 500 - [@dblock](https://github.com/dblock). * [#526](https://github.com/ruby-grape/grape/pull/526): Allowed specifying headers in `error!` - [@dblock](https://github.com/dblock). * [#527](https://github.com/ruby-grape/grape/pull/527): The `before_validation` callback is now a distinct one - [@myitcv](https://github.com/myitcv). * [#530](https://github.com/ruby-grape/grape/pull/530): Added ability to restrict `declared(params)` to the local endpoint with `include_parent_namespaces: false` - [@myitcv](https://github.com/myitcv). * [#531](https://github.com/ruby-grape/grape/pull/531): Helpers are now available to auth middleware, executing in the context of the endpoint - [@joelvh](https://github.com/joelvh). * [#540](https://github.com/ruby-grape/grape/pull/540): Ruby 2.1.0 is now supported - [@salimane](https://github.com/salimane). * [#544](https://github.com/ruby-grape/grape/pull/544): The `rescue_from` keyword now handles subclasses of exceptions by default - [@xevix](https://github.com/xevix). * [#545](https://github.com/ruby-grape/grape/pull/545): Added `type` (`Array` or `Hash`) support to `requires`, `optional` and `group` - [@bwalex](https://github.com/bwalex). * [#550](https://github.com/ruby-grape/grape/pull/550): Added possibility to define reusable params - [@dm1try](https://github.com/dm1try). * [#560](https://github.com/ruby-grape/grape/pull/560): Use `Grape::Entity` documentation to define required and optional parameters with `requires using:` - [@reynardmh](https://github.com/reynardmh). * [#572](https://github.com/ruby-grape/grape/pull/572): Added `documentation` support to `requires`, `optional` and `group` parameters - [@johnallen3d](https://github.com/johnallen3d). #### Fixes * [#600](https://github.com/ruby-grape/grape/pull/600): Don't use an `Entity` constant that is available in the namespace as presenter - [@fuksito](https://github.com/fuksito). * [#590](https://github.com/ruby-grape/grape/pull/590): Fix issue where endpoint param of type `Integer` cannot set values array - [@xevix](https://github.com/xevix). * [#586](https://github.com/ruby-grape/grape/pull/586): Do not repeat the same validation error messages - [@kiela](https://github.com/kiela). * [#508](https://github.com/ruby-grape/grape/pull/508): Allow parameters, such as content encoding, in `content_type` - [@dm1try](https://github.com/dm1try). * [#492](https://github.com/ruby-grape/grape/pull/492): Don't allow to have nil value when a param is required and has a list of allowed values - [@Antti](https://github.com/Antti). * [#495](https://github.com/ruby-grape/grape/pull/495): Fixed `ParamsScope#params` for parameters nested inside arrays - [@asross](https://github.com/asross). * [#498](https://github.com/ruby-grape/grape/pull/498): Dry'ed up options and headers logic, allow headers to be passed to OPTIONS requests - [@karlfreeman](https://github.com/karlfreeman). * [#500](https://github.com/ruby-grape/grape/pull/500): Skip entity auto-detection when explicitely passed - [@yaneq](https://github.com/yaneq). * [#503](https://github.com/ruby-grape/grape/pull/503): Calling declared(params) from child namespace fails to include parent namespace defined params - [@myitcv](https://github.com/myitcv). * [#512](https://github.com/ruby-grape/grape/pull/512): Don't create `Grape::Request` multiple times - [@dblock](https://github.com/dblock). * [#538](https://github.com/ruby-grape/grape/pull/538): Fixed default values for grouped params - [@dm1try](https://github.com/dm1try). * [#549](https://github.com/ruby-grape/grape/pull/549): Fixed handling of invalid version headers to return 406 if a header cannot be parsed - [@bwalex](https://github.com/bwalex). * [#557](https://github.com/ruby-grape/grape/pull/557): Pass `content_types` option to `Grape::Middleware::Error` to fix the content-type header for custom formats. - [@bernd](https://github.com/bernd). * [#585](https://github.com/ruby-grape/grape/pull/585): Fix after boot thread-safety issue - [@etehtsea](https://github.com/etehtsea). * [#587](https://github.com/ruby-grape/grape/pull/587): Fix oauth2 middleware compatibility with [draft-ietf-oauth-v2-31](http://tools.ietf.org/html/draft-ietf-oauth-v2-31) spec - [@etehtsea](https://github.com/etehtsea). * [#610](https://github.com/ruby-grape/grape/pull/610): Fixed group keyword was not working with type parameter - [@klausmeyer](https://github.com/klausmeyer/). 0.6.1 (10/19/2013) ================== #### Features * [#475](https://github.com/ruby-grape/grape/pull/475): Added support for the `:jsonapi`, `application/vnd.api+json` media type registered at http://jsonapi.org - [@bcm](https://github.com/bcm). * [#471](https://github.com/ruby-grape/grape/issues/471): Added parameter validator for a list of allowed values - [@vickychijwani](https://github.com/vickychijwani). * [#488](https://github.com/ruby-grape/grape/issues/488): Upgraded to Virtus 1.0 - [@dblock](https://github.com/dblock). #### Fixes * [#477](https://github.com/ruby-grape/grape/pull/477): Fixed `default_error_formatter` which takes a format symbol - [@vad4msiu](https://github.com/vad4msiu). #### Development * Implemented Rubocop, a Ruby code static code analyzer - [@dblock](https://github.com/dblock). 0.6.0 (9/16/2013) ================= #### Features * Grape is no longer tested against Ruby 1.8.7. * [#442](https://github.com/ruby-grape/grape/issues/442): Enable incrementally building on top of a previous API version - [@dblock](https://github.com/dblock). * [#442](https://github.com/ruby-grape/grape/issues/442): API `version` can now take an array of multiple versions - [@dblock](https://github.com/dblock). * [#444](https://github.com/ruby-grape/grape/issues/444): Added `:en` as fallback locale for I18n - [@aew](https://github.com/aew). * [#448](https://github.com/ruby-grape/grape/pull/448): Adding POST style parameters for DELETE requests - [@dquimper](https://github.com/dquimper). * [#450](https://github.com/ruby-grape/grape/pull/450): Added option to pass an exception handler lambda as an argument to `rescue_from` - [@robertopedroso](https://github.com/robertopedroso). * [#443](https://github.com/ruby-grape/grape/pull/443): Let `requires` and `optional` take blocks that initialize new scopes - [@asross](https://github.com/asross). * [#452](https://github.com/ruby-grape/grape/pull/452): Added `with` as a hash option to specify handlers for `rescue_from` and `error_formatter` [@robertopedroso](https://github.com/robertopedroso). * [#433](https://github.com/ruby-grape/grape/issues/433), [#462](https://github.com/ruby-grape/grape/issues/462): Validation errors are now collected and `Grape::Exceptions::ValidationErrors` is raised - [@stevschmid](https://github.com/stevschmid). #### Fixes * [#428](https://github.com/ruby-grape/grape/issues/428): Removes memoization from `Grape::Request` params to prevent middleware from freezing parameter values before `Formatter` can get them - [@mbleigh](https://github.com/mbleigh). 0.5.0 (6/14/2013) ================= #### Features * [#344](https://github.com/ruby-grape/grape/pull/344): Added `parser :type, nil` which disables input parsing for a given content-type - [@dblock](https://github.com/dblock). * [#381](https://github.com/ruby-grape/grape/issues/381): Added `cascade false` option at API level to remove the `X-Cascade: true` header from the API response - [@dblock](https://github.com/dblock). * [#392](https://github.com/ruby-grape/grape/pull/392): Extracted headers and params from `Endpoint` to `Grape::Request` - [@niedhui](https://github.com/niedhui). * [#376](https://github.com/ruby-grape/grape/pull/376): Added `route_param`, syntax sugar for quick declaration of route parameters - [@mbleigh](https://github.com/mbleigh). * [#390](https://github.com/ruby-grape/grape/pull/390): Added default value for an `optional` parameter - [@oivoodoo](https://github.com/oivoodoo). * [#403](https://github.com/ruby-grape/grape/pull/403): Added support for versioning using the `Accept-Version` header - [@politician](https://github.com/politician). * [#407](https://github.com/ruby-grape/grape/issues/407): Specifying `default_format` will also set the default POST/PUT data parser to the given format - [@dblock](https://github.com/dblock). * [#241](https://github.com/ruby-grape/grape/issues/241): Present with multiple entities using an optional Symbol - [@niedhui](https://github.com/niedhui). #### Fixes * [#378](https://github.com/ruby-grape/grape/pull/378): Fix: stop rescuing all exceptions during formatting - [@kbarrette](https://github.com/kbarrette). * [#380](https://github.com/ruby-grape/grape/pull/380): Fix: `Formatter#read_body_input` when transfer encoding is chunked - [@paulnicholon](https://github.com/paulnicholson). * [#347](https://github.com/ruby-grape/grape/issues/347): Fix: handling non-hash body params - [@paulnicholon](https://github.com/paulnicholson). * [#394](https://github.com/ruby-grape/grape/pull/394): Fix: path version no longer overwrites a `version` parameter - [@tmornini](https://github.com/tmornini). * [#412](https://github.com/ruby-grape/grape/issues/412): Fix: specifying `content_type` will also override the selection of the data formatter - [@dblock](https://github.com/dblock). * [#383](https://github.com/ruby-grape/grape/issues/383): Fix: Mounted APIs aren't inheriting settings (including `before` and `after` filters) - [@seanmoon](https://github.com/seanmoon). * [#408](https://github.com/ruby-grape/grape/pull/408): Fix: Goliath passes request header keys as symbols not strings - [@bobek](https://github.com/bobek). * [#417](https://github.com/ruby-grape/grape/issues/417): Fix: Rails 4 does not rewind input, causes POSTed data to be empty - [@dblock](https://github.com/dblock). * [#423](https://github.com/ruby-grape/grape/pull/423): Fix: `Grape::Endpoint#declared` now correctly handles nested params (ie. declared with `group`) - [@jbarreneche](https://github.com/jbarreneche). * [#427](https://github.com/ruby-grape/grape/issues/427): Fix: `declared(params)` breaks when `params` contains array - [@timhabermaas](https://github.com/timhabermaas) 0.4.1 (4/1/2013) ================ * [#375](https://github.com/ruby-grape/grape/pull/375): Fix: throwing an `:error` inside a middleware doesn't respect the `format` settings - [@dblock](https://github.com/dblock). 0.4.0 (3/17/2013) ================= * [#356](https://github.com/ruby-grape/grape/pull/356): Fix: presenting collections other than `Array` (eg. `ActiveRecord::Relation`) - [@zimbatm](https://github.com/zimbatm). * [#352](https://github.com/ruby-grape/grape/pull/352): Fix: using `Rack::JSONP` with `Grape::Entity` responses - [@deckchair](https://github.com/deckchair). * [#347](https://github.com/ruby-grape/grape/issues/347): Grape will accept any valid JSON as PUT or POST, including strings, symbols and arrays - [@qqshfox](https://github.com/qqshfox), [@dblock](https://github.com/dblock). * [#347](https://github.com/ruby-grape/grape/issues/347): JSON format APIs always return valid JSON, eg. strings are now returned as `"string"` and no longer `string` - [@dblock](https://github.com/dblock). * Raw body input from POST and PUT requests (`env['rack.input'].read`) is now available in `api.request.input` - [@dblock](https://github.com/dblock). * Parsed body input from POST and PUT requests is now available in `api.request.body` - [@dblock](https://github.com/dblock). * [#343](https://github.com/ruby-grape/grape/pull/343): Fix: return `Content-Type: text/plain` with error 405 - [@gustavosaume](https://github.com/gustavosaume), [@wyattisimo](https://github.com/wyattisimo). * [#357](https://github.com/ruby-grape/grape/pull/357): Grape now requires Rack 1.3.0 or newer - [@jhecking](https://github.com/jhecking). * [#320](https://github.com/ruby-grape/grape/issues/320): API `namespace` now supports `requirements` - [@niedhui](https://github.com/niedhui). * [#353](https://github.com/ruby-grape/grape/issues/353): Revert to standard Ruby logger formatter, `require active_support/all` if you want old behavior - [@rhunter](https://github.com/rhunter), [@dblock](https://github.com/dblock). * Fix: `undefined method 'call' for nil:NilClass` for an API method implementation without a block, now returns an empty string - [@dblock](https://github.com/dblock). 0.3.2 (2/28/2013) ================= * [#355](https://github.com/ruby-grape/grape/issues/355): Relax dependency constraint on Hashie - [@reset](https://github.com/reset). 0.3.1 (2/25/2013) ================= * [#351](https://github.com/ruby-grape/grape/issues/351): Compatibility with Ruby 2.0 - [@mbleigh](https://github.com/mbleigh). 0.3.0 (02/21/2013) ================== * [#294](https://github.com/ruby-grape/grape/issues/294): Extracted `Grape::Entity` into a [grape-entity](https://github.com/agileanimal/grape-entity) gem - [@agileanimal](https://github.com/agileanimal). * [#340](https://github.com/ruby-grape/grape/pull/339), [#342](https://github.com/ruby-grape/grape/pull/342): Added `:cascade` option to `version` to allow disabling of rack/mount cascade behavior - [@dieb](https://github.com/dieb). * [#333](https://github.com/ruby-grape/grape/pull/333): Added support for validation of arrays in `params` - [@flyerhzm](https://github.com/flyerhzm). * [#306](https://github.com/ruby-grape/grape/issues/306): Added I18n support for all Grape exceptions - [@niedhui](https://github.com/niedhui). * [#309](https://github.com/ruby-grape/grape/pull/309): Added XML support to the entity presenter - [@johnnyiller](https://github.com/johnnyiller), [@dblock](http://github.com/dblock). * [#131](https://github.com/ruby-grape/grape/issues/131): Added instructions for Grape API reloading in Rails - [@jyn](http://github.com/jyn), [@dblock](http://github.com/dblock). * [#317](https://github.com/ruby-grape/grape/issues/317): Added `headers` that returns a hash of parsed HTTP request headers - [@dblock](http://github.com/dblock). * [#332](https://github.com/ruby-grape/grape/pull/332): `Grape::Exceptions::Validation` now contains full nested parameter names - [@alovak](https://github.com/alovak). * [#328](https://github.com/ruby-grape/grape/issues/328): API version can now be specified as both String and Symbol - [@dblock](http://github.com/dblock). * [#190](https://github.com/ruby-grape/grape/issues/190): When you add a `GET` route for a resource, a route for the `HEAD` method will also be added automatically. You can disable this behavior with `do_not_route_head!` - [@dblock](http://github.com/dblock). * Added `do_not_route_options!`, which disables the automatic creation of the `OPTIONS` route - [@dblock](http://github.com/dblock). * [#309](https://github.com/ruby-grape/grape/pull/309): An XML format API will return an error instead of returning a string representation of the response if the latter cannot be converted to XML - [@dblock](http://github.com/dblock). * A formatter that raises an exception will cause the API to return a 500 error - [@dblock](http://github.com/dblock). * [#322](https://github.com/ruby-grape/grape/issues/322): When returning a 406 status, Grape will include the requested format or content-type in the response body - [@dblock](http://github.com/dblock). * [#60](https://github.com/ruby-grape/grape/issues/60): Fix: mounting of a Grape API onto a path - [@dblock](http://github.com/dblock). * [#335](https://github.com/ruby-grape/grape/pull/335): Fix: request body parameters from a `PATCH` request not available in `params` - [@FreakenK](http://github.com/FreakenK). 0.2.6 (01/11/2013) ================== * Fix: support content-type with character set when parsing POST and PUT input - [@dblock](http://github.com/dblock). * Fix: CVE-2013-0175, multi_xml parse vulnerability, require multi_xml 0.5.2 - [@dblock](http://github.com/dblock). 0.2.5 (01/10/2013) ================== * Added support for custom parsers via `parser`, in addition to built-in multipart, JSON and XML parsers - [@dblock](http://github.com/dblock). * Removed `body_params`, data sent via a POST or PUT with a supported content-type is merged into `params` - [@dblock](http://github.com/dblock). * Setting `format` will automatically remove other content-types by calling `content_type` - [@dblock](http://github.com/dblock). * Setting `content_type` will prevent any input data other than the matching content-type or any Rack-supported form and parseable media types (`application/x-www-form-urlencoded`, `multipart/form-data`, `multipart/related` and `multipart/mixed`) from being parsed - [@dblock](http://github.com/dblock). * [#305](https://github.com/ruby-grape/grape/issues/305): Fix: presenting arrays of objects via `represent` or when auto-detecting an `Entity` constant in the objects being presented - [@brandonweiss](https://github.com/brandonweiss). * [#306](https://github.com/ruby-grape/grape/issues/306): Added i18n support for validation error messages - [@niedhui](https://github.com/niedhui). 0.2.4 (01/06/2013) ================== * [#297](https://github.com/ruby-grape/grape/issues/297): Added `default_error_formatter` - [@dblock](https://github.com/dblock). * [#297](https://github.com/ruby-grape/grape/issues/297): Setting `format` will automatically set `default_error_formatter` - [@dblock](https://github.com/dblock). * [#295](https://github.com/ruby-grape/grape/issues/295): Storing original API source block in endpoint's `source` attribute - [@dblock](https://github.com/dblock). * [#293](https://github.com/ruby-grape/grape/pull/293): Added options to `cookies.delete`, enables passing a path - [@inst](https://github.com/inst). * [#174](https://github.com/ruby-grape/grape/issues/174): The value of `env['PATH_INFO']` is no longer altered with `path` versioning - [@dblock](https://github.com/dblock). * [#296](https://github.com/ruby-grape/grape/issues/296): Fix: ArgumentError with default error formatter - [@dblock](https://github.com/dblock). * [#298](https://github.com/ruby-grape/grape/pull/298): Fix: subsequent calls to `body_params` would fail due to IO read - [@justinmcp](https://github.com/justinmcp). * [#301](https://github.com/ruby-grape/grape/issues/301): Fix: symbol memory leak in cookie and formatter middleware - [@dblock](https://github.com/dblock). * [#300](https://github.com/ruby-grape/grape/issues/300): Fix `Grape::API.routes` to include mounted api routes - [@aiwilliams](https://github.com/aiwilliams). * [#302](https://github.com/ruby-grape/grape/pull/302): Fix: removed redundant `autoload` entries - [@ugisozols](https://github.com/ugisozols). * [#172](https://github.com/ruby-grape/grape/issues/172): Fix: MultiJson deprecated methods warnings - [@dblock](https://github.com/dblock). * [#133](https://github.com/ruby-grape/grape/issues/133): Fix: header-based versioning with use of `prefix` - [@seanmoon](https://github.com/seanmoon), [@dblock](https://github.com/dblock). * [#280](https://github.com/ruby-grape/grape/issues/280): Fix: grouped parameters mangled in `route_params` hash - [@marcusg](https://github.com/marcusg), [@dblock](https://github.com/dblock). * [#304](https://github.com/ruby-grape/grape/issues/304): Fix: `present x, :with => Entity` returns class references with `format :json` - [@dblock](https://github.com/dblock). * [#196](https://github.com/ruby-grape/grape/issues/196): Fix: root requests don't work with `prefix` - [@dblock](https://github.com/dblock). 0.2.3 (24/12/2012) ================== * [#179](https://github.com/ruby-grape/grape/issues/178): Using `content_type` will remove all default content-types - [@dblock](https://github.com/dblock). * [#265](https://github.com/ruby-grape/grape/issues/264): Fix: Moved `ValidationError` into `Grape::Exceptions` - [@thepumpkin1979](https://github.com/thepumpkin1979). * [#269](https://github.com/ruby-grape/grape/pull/269): Fix: `LocalJumpError` will not be raised when using explict return in API methods - [@simulacre](https://github.com/simulacre). * [#86](https://github.com/ruby-grape/grape/issues/275): Fix Path-based versioning not recognizing `/` route - [@walski](https://github.com/walski). * [#273](https://github.com/ruby-grape/grape/pull/273): Disabled formatting via `serializable_hash` and added support for `format :serializable_hash` - [@dblock](https://github.com/dblock). * [#277](https://github.com/ruby-grape/grape/pull/277): Added a DSL to declare `formatter` in API settings - [@tim-vandecasteele](https://github.com/tim-vandecasteele). * [#284](https://github.com/ruby-grape/grape/pull/284): Added a DSL to declare `error_formatter` in API settings - [@dblock](https://github.com/dblock). * [#285](https://github.com/ruby-grape/grape/pull/285): Removed `error_format` from API settings, now matches request format - [@dblock](https://github.com/dblock). * [#290](https://github.com/ruby-grape/grape/pull/290): The default error format for XML is now `error/message` instead of `hash/error` - [@dpsk](https://github.com/dpsk). * [#44](https://github.com/ruby-grape/grape/issues/44): Pass `env` into formatters to enable templating - [@dblock](https://github.com/dblock). 0.2.2 ===== #### Features * [#201](https://github.com/ruby-grape/grape/pull/201), [#236](https://github.com/ruby-grape/grape/pull/236), [#221](https://github.com/ruby-grape/grape/pull/221): Added coercion and validations support to `params` DSL - [@schmurfy](https://github.com/schmurfy), [@tim-vandecasteele](https://github.com/tim-vandecasteele), [@adamgotterer](https://github.com/adamgotterer). * [#204](https://github.com/ruby-grape/grape/pull/204): Added ability to declare shared `params` at `namespace` level - [@tim-vandecasteele](https://github.com/tim-vandecasteele). * [#234](https://github.com/ruby-grape/grape/pull/234): Added a DSL for creating entities via mixin - [@mbleigh](https://github.com/mbleigh). * [#240](https://github.com/ruby-grape/grape/pull/240): Define API response format from a query string `format` parameter, if specified - [@neetiraj](https://github.com/neetiraj). * Adds Endpoint#declared to easily filter out unexpected params. - [@mbleigh](https://github.com/mbleigh) #### Fixes * [#248](https://github.com/ruby-grape/grape/pull/248): Fix: API `version` returns last version set - [@narkoz](https://github.com/narkoz). * [#242](https://github.com/ruby-grape/grape/issues/242): Fix: permanent redirect status should be `301`, was `304` - [@adamgotterer](https://github.com/adamgotterer). * [#211](https://github.com/ruby-grape/grape/pull/211): Fix: custom validations are no longer triggered when optional and parameter is not present - [@adamgotterer](https://github.com/adamgotterer). * [#210](https://github.com/ruby-grape/grape/pull/210): Fix: `Endpoint#body_params` causing undefined method 'size' - [@adamgotterer](https://github.com/adamgotterer). * [#205](https://github.com/ruby-grape/grape/pull/205): Fix: Corrected parsing of empty JSON body on POST/PUT - [@tim-vandecasteele](https://github.com/tim-vandecasteele). * [#181](https://github.com/ruby-grape/grape/pull/181): Fix: Corrected JSON serialization of nested hashes containing `Grape::Entity` instances - [@benrosenblum](https://github.com/benrosenblum). * [#203](https://github.com/ruby-grape/grape/pull/203): Added a check to `Entity#serializable_hash` that verifies an entity exists on an object - [@adamgotterer](https://github.com/adamgotterer). * [#208](https://github.com/ruby-grape/grape/pull/208): `Entity#serializable_hash` must also check if attribute is generated by a user supplied block - [@ppadron](https://github.com/ppadron). * [#252](https://github.com/ruby-grape/grape/pull/252): Resources that don't respond to a requested HTTP method return 405 (Method Not Allowed) instead of 404 (Not Found) - [@simulacre](https://github.com/simulacre) 0.2.1 (7/11/2012) ================= * [#186](https://github.com/ruby-grape/grape/issues/186): Fix: helpers allow multiple calls with modules and blocks - [@ppadron](https://github.com/ppadron). * [#188](https://github.com/ruby-grape/grape/pull/188): Fix: multi-method routes append '(.:format)' only once - [@kainosnoema](https://github.com/kainosnoema). * [#64](https://github.com/ruby-grape/grape/issues/64), [#180](https://github.com/ruby-grape/grape/pull/180): Added support to `GET` request bodies as parameters - [@bobbytables](https://github.com/bobbytables). * [#175](https://github.com/ruby-grape/grape/pull/175): Added support for API versioning based on a request parameter - [@jackcasey](https://github.com/jackcasey). * [#168](https://github.com/ruby-grape/grape/pull/168): Fix: Formatter can parse symbol keys in the headers hash - [@netmask](https://github.com/netmask). * [#169](https://github.com/ruby-grape/grape/pull/169): Silence multi_json deprecation warnings - [@whiteley](https://github.com/whiteley). * [#166](https://github.com/ruby-grape/grape/pull/166): Added support for `redirect`, including permanent and temporary - [@allenwei](https://github.com/allenwei). * [#159](https://github.com/ruby-grape/grape/pull/159): Added `:requirements` to routes, allowing to use reserved characters in paths - [@gaiottino](https://github.com/gaiottino). * [#156](https://github.com/ruby-grape/grape/pull/156): Added support for adding formatters to entities - [@bobbytables](https://github.com/bobbytables). * [#183](https://github.com/ruby-grape/grape/pull/183): Added ability to include documentation in entities - [@flah00](https://github.com/flah00). * [#189](https://github.com/ruby-grape/grape/pull/189): `HEAD` requests no longer return a body - [@stephencelis](https://github.com/stephencelis). * [#97](https://github.com/ruby-grape/grape/issues/97): Allow overriding `Content-Type` - [@dblock](https://github.com/dblock). 0.2.0 (3/28/2012) ================= * Added support for inheriting exposures from entities - [@bobbytables](https://github.com/bobbytables). * Extended formatting with `default_format` - [@dblock](https://github.com/dblock). * Added support for cookies - [@lukaszsliwa](https://github.com/lukaszsliwa). * Added support for declaring additional content-types - [@joeyAghion](https://github.com/joeyAghion). * Added support for HTTP PATCH - [@LTe](https://github.com/LTe). * Added support for describing, documenting and reflecting APIs - [@dblock](https://github.com/dblock). * Added support for anchoring and vendoring - [@jwkoelewijn](https://github.com/jwkoelewijn). * Added support for HTTP OPTIONS - [@grimen](https://github.com/grimen). * Added support for silencing logger - [@evansj](https://github.com/evansj). * Added support for helper modules - [@freelancing-god](https://github.com/freelancing-god). * Added support for Accept header-based versioning - [@jch](https://github.com/jch), [@rodzyn](https://github.com/rodzyn). * Added support for mounting APIs and other Rack applications within APIs - [@mbleigh](https://github.com/mbleigh). * Added entities, multiple object representations - [@mbleigh](https://github.com/mbleigh). * Added ability to handle XML in the incoming request body - [@jwillis](https://github.com/jwillis). * Added support for a configurable logger - [@mbleigh](https://github.com/mbleigh). * Added support for before and after filters - [@mbleigh](https://github.com/mbleigh). * Extended `rescue_from`, which can now take a block - [@dblock](https://github.com/dblock). 0.1.5 (6/14/2011) ================== * Extended exception handling to all exceptions - [@dblock](https://github.com/dblock). * Added support for returning JSON objects from within error blocks - [@dblock](https://github.com/dblock). * Added support for handling incoming JSON in body - [@tedkulp](https://github.com/tedkulp). * Added support for HTTP digest authentication - [@daddz](https://github.com/daddz). 0.1.4 (4/8/2011) ================== * Allow multiple definitions of the same endpoint under multiple versions - [@chrisrhoden](https://github.com/chrisrhoden). * Added support for multipart URL parameters - [@mcastilho](https://github.com/mcastilho). * Added support for custom formatters - [@spraints](https://github.com/spraints). 0.1.3 (1/10/2011) ================== * Added support for JSON format in route matching - [@aiwilliams](https://github.com/aiwilliams). * Added suport for custom middleware - [@mbleigh](https://github.com/mbleigh). 0.1.1 (11/14/2010) ================== * Endpoints properly reset between each request - [@mbleigh](https://github.com/mbleigh). 0.1.0 (11/13/2010) ================== * Initial public release - [@mbleigh](https://github.com/mbleigh). grape-0.16.2/tmp/0000755000004100000410000000000012706307017013531 5ustar www-datawww-datagrape-0.16.2/tmp/Gemfile.lock0000644000004100000410000000252212706307017015754 0ustar www-datawww-dataGIT remote: git://github.com/ruby-grape/grape.git revision: 951ae51cc0eccec6c5225c2aaf16f091829062dd specs: grape (0.14.1) activesupport builder hashie (>= 2.1.0) multi_json (>= 1.3.2) multi_xml (>= 0.5.2) rack (>= 1.3.0) rack-accept rack-mount virtus (>= 1.0.0) GEM remote: https://rubygems.org/ specs: activesupport (4.2.5) i18n (~> 0.7) json (~> 1.7, >= 1.7.7) minitest (~> 5.1) thread_safe (~> 0.3, >= 0.3.4) tzinfo (~> 1.1) axiom-types (0.1.1) descendants_tracker (~> 0.0.4) ice_nine (~> 0.11.0) thread_safe (~> 0.3, >= 0.3.1) builder (3.2.2) coercible (1.0.0) descendants_tracker (~> 0.0.1) descendants_tracker (0.0.4) thread_safe (~> 0.3, >= 0.3.1) equalizer (0.0.11) hashie (3.4.3) i18n (0.7.0) ice_nine (0.11.1) json (1.8.3) minitest (5.8.3) multi_json (1.11.2) multi_xml (0.5.5) rack (1.6.4) rack-accept (0.4.5) rack (>= 0.4) rack-mount (0.8.3) rack (>= 1.0.0) thread_safe (0.3.5) tzinfo (1.2.2) thread_safe (~> 0.1) virtus (1.0.5) axiom-types (~> 0.1) coercible (~> 1.0) descendants_tracker (~> 0.0, >= 0.0.3) equalizer (~> 0.0, >= 0.0.9) PLATFORMS ruby DEPENDENCIES grape! BUNDLED WITH 1.10.6 grape-0.16.2/README.md0000644000004100000410000024110712706307016014214 0ustar www-datawww-data![grape logo](grape.png) [![Gem Version](https://badge.fury.io/rb/grape.svg)](http://badge.fury.io/rb/grape) [![Build Status](https://travis-ci.org/ruby-grape/grape.svg?branch=master)](https://travis-ci.org/ruby-grape/grape) [![Dependency Status](https://gemnasium.com/ruby-grape/grape.svg)](https://gemnasium.com/ruby-grape/grape) [![Code Climate](https://codeclimate.com/github/ruby-grape/grape.svg)](https://codeclimate.com/github/ruby-grape/grape) [![Inline docs](http://inch-ci.org/github/ruby-grape/grape.svg)](http://inch-ci.org/github/ruby-grape/grape) [![Join the chat at https://gitter.im/ruby-grape/grape](https://badges.gitter.im/ruby-grape/grape.svg)](https://gitter.im/ruby-grape/grape?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) ## Table of Contents - [What is Grape?](#what-is-grape) - [Stable Release](#stable-release) - [Project Resources](#project-resources) - [Installation](#installation) - [Basic Usage](#basic-usage) - [Mounting](#mounting) - [Rack](#rack) - [ActiveRecord without Rails](#activerecord-without-rails) - [Alongside Sinatra (or other frameworks)](#alongside-sinatra-or-other-frameworks) - [Rails](#rails) - [Modules](#modules) - [Versioning](#versioning) - [Path](#path) - [Header](#header) - [Accept-Version Header](#accept-version-header) - [Param](#param) - [Describing Methods](#describing-methods) - [Parameters](#parameters) - [Declared](#declared) - [Include Missing](#include-missing) - [Parameter Validation and Coercion](#parameter-validation-and-coercion) - [Supported Parameter Types](#supported-parameter-types) - [Custom Types and Coercions](#custom-types-and-coercions) - [Multipart File Parameters](#multipart-file-parameters) - [First-Class `JSON` Types](#first-class-json-types) - [Multiple Allowed Types](#multiple-allowed-types) - [Validation of Nested Parameters](#validation-of-nested-parameters) - [Dependent Parameters](#dependent-parameters) - [Built-in Validators](#built-in-validators) - [Namespace Validation and Coercion](#namespace-validation-and-coercion) - [Custom Validators](#custom-validators) - [Validation Errors](#validation-errors) - [I18n](#i18n) - [Custom Validation Messages](#custom-validation-messages) - [Headers](#headers) - [Routes](#routes) - [Helpers](#helpers) - [Path Helpers](#path-helpers) - [Parameter Documentation](#parameter-documentation) - [Cookies](#cookies) - [HTTP Status Code](#http-status-code) - [Redirecting](#redirecting) - [Recognizing Path](#recognizing-path) - [Allowed Methods](#allowed-methods) - [Raising Exceptions](#raising-exceptions) - [Default Error HTTP Status Code](#default-error-http-status-code) - [Handling 404](#handling-404) - [Exception Handling](#exception-handling) - [Rails 3.x](#rails-3x) - [Logging](#logging) - [API Formats](#api-formats) - [JSONP](#jsonp) - [CORS](#cors) - [Content-type](#content-type) - [API Data Formats](#api-data-formats) - [RESTful Model Representations](#restful-model-representations) - [Grape Entities](#grape-entities) - [Hypermedia and Roar](#hypermedia-and-roar) - [Rabl](#rabl) - [Active Model Serializers](#active-model-serializers) - [Sending Raw or No Data](#sending-raw-or-no-data) - [Authentication](#authentication) - [Describing and Inspecting an API](#describing-and-inspecting-an-api) - [Current Route and Endpoint](#current-route-and-endpoint) - [Before and After](#before-and-after) - [Anchoring](#anchoring) - [Using Custom Middleware](#using-custom-middleware) - [Grape Middleware](#grape-middleware) - [Rails Middleware](#rails-middleware) - [Remote IP](#remote-ip) - [Writing Tests](#writing-tests) - [Writing Tests with Rack](#writing-tests-with-rack) - [Writing Tests with Rails](#writing-tests-with-rails) - [Stubbing Helpers](#stubbing-helpers) - [Reloading API Changes in Development](#reloading-api-changes-in-development) - [Reloading in Rack Applications](#reloading-in-rack-applications) - [Reloading in Rails Applications](#reloading-in-rails-applications) - [Performance Monitoring](#performance-monitoring) - [Active Support Instrumentation](#active-support-instrumentation) - [Monitoring Products](#monitoring-products) - [Contributing to Grape](#contributing-to-grape) - [License](#license) - [Copyright](#copyright) ## What is Grape? Grape is a REST-like API micro-framework for Ruby. It's designed to run on Rack or complement existing web application frameworks such as Rails and Sinatra by providing a simple DSL to easily develop RESTful APIs. It has built-in support for common conventions, including multiple formats, subdomain/prefix restriction, content negotiation, versioning and much more. ## Stable Release You're reading the documentation for the stable release of Grape, 0.16.2. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version. ## Project Resources * [Grape Website](http://www.ruby-grape.org) * Need help? [Grape Google Group](http://groups.google.com/group/ruby-grape) ## Installation Grape is available as a gem, to install it just install the gem: gem install grape If you're using Bundler, add the gem to Gemfile. gem 'grape' Run `bundle install`. ## Basic Usage Grape APIs are Rack applications that are created by subclassing `Grape::API`. Below is a simple example showing some of the more common features of Grape in the context of recreating parts of the Twitter API. ```ruby module Twitter class API < Grape::API version 'v1', using: :header, vendor: 'twitter' format :json prefix :api helpers do def current_user @current_user ||= User.authorize!(env) end def authenticate! error!('401 Unauthorized', 401) unless current_user end end resource :statuses do desc 'Return a public timeline.' get :public_timeline do Status.limit(20) end desc 'Return a personal timeline.' get :home_timeline do authenticate! current_user.statuses.limit(20) end desc 'Return a status.' params do requires :id, type: Integer, desc: 'Status id.' end route_param :id do get do Status.find(params[:id]) end end desc 'Create a status.' params do requires :status, type: String, desc: 'Your status.' end post do authenticate! Status.create!({ user: current_user, text: params[:status] }) end desc 'Update a status.' params do requires :id, type: String, desc: 'Status ID.' requires :status, type: String, desc: 'Your status.' end put ':id' do authenticate! current_user.statuses.find(params[:id]).update({ user: current_user, text: params[:status] }) end desc 'Delete a status.' params do requires :id, type: String, desc: 'Status ID.' end delete ':id' do authenticate! current_user.statuses.find(params[:id]).destroy end end end end ``` ## Mounting ### Rack The above sample creates a Rack application that can be run from a rackup `config.ru` file with `rackup`: ```ruby run Twitter::API ``` And would respond to the following routes: GET /api/statuses/public_timeline GET /api/statuses/home_timeline GET /api/statuses/:id POST /api/statuses PUT /api/statuses/:id DELETE /api/statuses/:id Grape will also automatically respond to HEAD and OPTIONS for all GET, and just OPTIONS for all other routes. ### ActiveRecord without Rails If you want to use ActiveRecord within Grape, you will need to make sure that ActiveRecord's connection pool is handled correctly. The easiest way to achieve that is by using ActiveRecord's `ConnectionManagement` middleware in your `config.ru` before mounting Grape, e.g.: ```ruby use ActiveRecord::ConnectionAdapters::ConnectionManagement run Twitter::API ``` ### Alongside Sinatra (or other frameworks) If you wish to mount Grape alongside another Rack framework such as Sinatra, you can do so easily using `Rack::Cascade`: ```ruby # Example config.ru require 'sinatra' require 'grape' class API < Grape::API get :hello do { hello: 'world' } end end class Web < Sinatra::Base get '/' do 'Hello world.' end end use Rack::Session::Cookie run Rack::Cascade.new [API, Web] ``` ### Rails Place API files into `app/api`. Rails expects a subdirectory that matches the name of the Ruby module and a file name that matches the name of the class. In our example, the file name location and directory for `Twitter::API` should be `app/api/twitter/api.rb`. Modify `application.rb`: ```ruby config.paths.add File.join('app', 'api'), glob: File.join('**', '*.rb') config.autoload_paths += Dir[Rails.root.join('app', 'api', '*')] ``` Modify `config/routes`: ```ruby mount Twitter::API => '/' ``` Additionally, if the version of your Rails is 4.0+ and the application uses the default model layer of ActiveRecord, you will want to use the [hashie-forbidden_attributes gem](https://github.com/Maxim-Filimonov/hashie-forbidden_attributes). This gem disables the security feature of `strong_params` at the model layer, allowing you the use of Grape's own params validation instead. ```ruby # Gemfile gem 'hashie-forbidden_attributes' ``` See [below](#reloading-api-changes-in-development) for additional code that enables reloading of API changes in development. ### Modules You can mount multiple API implementations inside another one. These don't have to be different versions, but may be components of the same API. ```ruby class Twitter::API < Grape::API mount Twitter::APIv1 mount Twitter::APIv2 end ``` You can also mount on a path, which is similar to using `prefix` inside the mounted API itself. ```ruby class Twitter::API < Grape::API mount Twitter::APIv1 => '/v1' end ``` ## Versioning There are four strategies in which clients can reach your API's endpoints: `:path`, `:header`, `:accept_version_header` and `:param`. The default strategy is `:path`. ### Path ```ruby version 'v1', using: :path ``` Using this versioning strategy, clients should pass the desired version in the URL. curl http://localhost:9292/v1/statuses/public_timeline ### Header ```ruby version 'v1', using: :header, vendor: 'twitter' ``` Currently, Grape only supports versioned media types in the following format: ``` vnd.vendor-and-or-resource-v1234+format ``` Basically all tokens between the final `-` and the `+` will be interpreted as the version. Using this versioning strategy, clients should pass the desired version in the HTTP `Accept` head. curl -H Accept:application/vnd.twitter-v1+json http://localhost:9292/statuses/public_timeline By default, the first matching version is used when no `Accept` header is supplied. This behavior is similar to routing in Rails. To circumvent this default behavior, one could use the `:strict` option. When this option is set to `true`, a `406 Not Acceptable` error is returned when no correct `Accept` header is supplied. When an invalid `Accept` header is supplied, a `406 Not Acceptable` error is returned if the `:cascade` option is set to `false`. Otherwise a `404 Not Found` error is returned by Rack if no other route matches. ### Accept-Version Header ```ruby version 'v1', using: :accept_version_header ``` Using this versioning strategy, clients should pass the desired version in the HTTP `Accept-Version` header. curl -H "Accept-Version:v1" http://localhost:9292/statuses/public_timeline By default, the first matching version is used when no `Accept-Version` header is supplied. This behavior is similar to routing in Rails. To circumvent this default behavior, one could use the `:strict` option. When this option is set to `true`, a `406 Not Acceptable` error is returned when no correct `Accept` header is supplied. ### Param ```ruby version 'v1', using: :param ``` Using this versioning strategy, clients should pass the desired version as a request parameter, either in the URL query string or in the request body. curl http://localhost:9292/statuses/public_timeline?apiver=v1 The default name for the query parameter is 'apiver' but can be specified using the `:parameter` option. ```ruby version 'v1', using: :param, parameter: 'v' ``` curl http://localhost:9292/statuses/public_timeline?v=v1 ## Describing Methods You can add a description to API methods and namespaces. ```ruby desc 'Returns your public timeline.' do detail 'more details' params API::Entities::Status.documentation success API::Entities::Entity failure [[401, 'Unauthorized', 'Entities::Error']] named 'My named route' headers XAuthToken: { description: 'Valdates your identity', required: true }, XOptionalHeader: { description: 'Not really needed', required: false } end get :public_timeline do Status.limit(20) end ``` * `detail`: A more enhanced description * `params`: Define parameters directly from an `Entity` * `success`: (former entity) The `Entity` to be used to present by default this route * `failure`: (former http_codes) A definition of the used failure HTTP Codes and Entities * `named`: A helper to give a route a name and find it with this name in the documentation Hash * `headers`: A definition of the used Headers ## Parameters Request parameters are available through the `params` hash object. This includes `GET`, `POST` and `PUT` parameters, along with any named parameters you specify in your route strings. ```ruby get :public_timeline do Status.order(params[:sort_by]) end ``` Parameters are automatically populated from the request body on `POST` and `PUT` for form input, JSON and XML content-types. The request: ``` curl -d '{"text": "140 characters"}' 'http://localhost:9292/statuses' -H Content-Type:application/json -v ``` The Grape endpoint: ```ruby post '/statuses' do Status.create!(text: params[:text]) end ``` Multipart POSTs and PUTs are supported as well. The request: ``` curl --form image_file='@image.jpg;type=image/jpg' http://localhost:9292/upload ``` The Grape endpoint: ```ruby post 'upload' do # file in params[:image_file] end ``` In the case of conflict between either of: * route string parameters * `GET`, `POST` and `PUT` parameters * the contents of the request body on `POST` and `PUT` route string parameters will have precedence. ### Declared Grape allows you to access only the parameters that have been declared by your `params` block. It filters out the params that have been passed, but are not allowed. Consider the following API endpoint: ````ruby format :json post 'users/signup' do { 'declared_params' => declared(params) } end ```` If we do not specify any params, `declared` will return an empty `Hashie::Mash` instance. **Request** ````bash curl -X POST -H "Content-Type: application/json" localhost:9292/users/signup -d '{"user": {"first_name":"first name", "last_name": "last name"}}' ```` **Response** ````json { "declared_params": {} } ```` Once we add parameters requirements, grape will start returning only the declared params. ````ruby format :json params do requires :user, type: Hash do requires :first_name, type: String requires :last_name, type: String end end post 'users/signup' do { 'declared_params' => declared(params) } end ```` **Request** ````bash curl -X POST -H "Content-Type: application/json" localhost:9292/users/signup -d '{"user": {"first_name":"first name", "last_name": "last name", "random": "never shown"}}' ```` **Response** ````json { "declared_params": { "user": { "first_name": "first name", "last_name": "last name" } } } ```` The returned hash is a `Hashie::Mash` instance, allowing you to access parameters via dot notation: ```ruby declared(params).user == declared(params)['user'] ``` The `#declared` method is not available to `before` filters, as those are evaluated prior to parameter coercion. ### Include missing By default `declared(params)` includes parameters that have `nil` values. If you want to return only the parameters that are not `nil`, you can use the `include_missing` option. By default, `include_missing` is set to `true`. Consider the following API: ````ruby format :json params do requires :first_name, type: String optional :last_name, type: String end post 'users/signup' do { 'declared_params' => declared(params, include_missing: false) } end ```` **Request** ````bash curl -X POST -H "Content-Type: application/json" localhost:9292/users/signup -d '{"user": {"first_name":"first name", "random": "never shown"}}' ```` **Response with include_missing:false** ````json { "declared_params": { "user": { "first_name": "first name" } } } ```` **Response with include_missing:true** ````json { "declared_params": { "first_name": "first name", "last_name": null } } ```` It also works on nested hashes: ````ruby format :json params do requires :user, type: Hash do requires :first_name, type: String optional :last_name, type: String requires :address, type: Hash do requires :city, type: String optional :region, type: String end end end post 'users/signup' do { 'declared_params' => declared(params, include_missing: false) } end ```` **Request** ````bash curl -X POST -H "Content-Type: application/json" localhost:9292/users/signup -d '{"user": {"first_name":"first name", "random": "never shown", "address": { "city": "SF"}}}' ```` **Response with include_missing:false** ````json { "declared_params": { "user": { "first_name": "first name", "address": { "city": "SF" } } } } ```` **Response with include_missing:true** ````json { "declared_params": { "user": { "first_name": "first name", "last_name": null, "address": { "city": "Zurich", "region": null } } } } ```` Note that an attribute with a `nil` value is not considered *missing* and will also be returned when `include_missing` is set to `false`: **Request** ````bash curl -X POST -H "Content-Type: application/json" localhost:9292/users/signup -d '{"user": {"first_name":"first name", "last_name": null, "address": { "city": "SF"}}}' ```` **Response with include_missing:false** ````json { "declared_params": { "user": { "first_name": "first name", "last_name": null, "address": { "city": "SF"} } } } ```` ## Parameter Validation and Coercion You can define validations and coercion options for your parameters using a `params` block. ```ruby params do requires :id, type: Integer optional :text, type: String, regexp: /\A[a-z]+\z/ group :media do requires :url end optional :audio do requires :format, type: Symbol, values: [:mp3, :wav, :aac, :ogg], default: :mp3 end mutually_exclusive :media, :audio end put ':id' do # params[:id] is an Integer end ``` When a type is specified an implicit validation is done after the coercion to ensure the output type is the one declared. Optional parameters can have a default value. ```ruby params do optional :color, type: String, default: 'blue' optional :random_number, type: Integer, default: -> { Random.rand(1..100) } optional :non_random_number, type: Integer, default: Random.rand(1..100) end ``` Note that default values will be passed through to any validation options specified. The following example will always fail if `:color` is not explicitly provided. ```ruby params do optional :color, type: String, default: 'blue', values: ['red', 'green'] end ``` The correct implementation is to ensure the default value passes all validations. ```ruby params do optional :color, type: String, default: 'blue', values: ['blue', 'red', 'green'] end ``` ### Supported Parameter Types The following are all valid types, supported out of the box by Grape: * Integer * Float * BigDecimal * Numeric * Date * DateTime * Time * Boolean * String * Symbol * Rack::Multipart::UploadedFile (alias `File`) * JSON ### Custom Types and Coercions Aside from the default set of supported types listed above, any class can be used as a type so long as an explicit coercion method is supplied. If the type implements a class-level `parse` method, Grape will use it automatically. This method must take one string argument and return an instance of the correct type, or raise an exception to indicate the value was invalid. E.g., ```ruby class Color attr_reader :value def initialize(color) @value = color end def self.parse(value) fail 'Invalid color' unless %w(blue red green).include?(value) new(value) end end # ... params do requires :color, type: Color, default: Color.new('blue') end get '/stuff' do # params[:color] is already a Color. params[:color].value end ``` Alternatively, a custom coercion method may be supplied for any type of parameter using `coerce_with`. Any class or object may be given that implements a `parse` or `call` method, in that order of precedence. The method must accept a single string parameter, and the return value must match the given `type`. ```ruby params do requires :passwd, type: String, coerce_with: Base64.method(:decode) requires :loud_color, type: Color, coerce_with: ->(c) { Color.parse(c.downcase) } requires :obj, type: Hash, coerce_with: JSON do requires :words, type: Array[String], coerce_with: ->(val) { val.split(/\s+/) } optional :time, type: Time, coerce_with: Chronic end end ``` Example of use of `coerce_with` with a lambda (a class with a `parse` method could also have been used) It will parse a string and return an Array of Integers, matching the `Array[Integer]` `type`. ```ruby params do requires :values, type: Array[Integer], coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) } end ``` ### Multipart File Parameters Grape makes use of `Rack::Request`'s built-in support for multipart file parameters. Such parameters can be declared with `type: File`: ```ruby params do requires :avatar, type: File end post '/' do # Parameter will be wrapped using Hashie: params.avatar.filename # => 'avatar.png' params.avatar.type # => 'image/png' params.avatar.tempfile # => # end ``` ### First-Class `JSON` Types Grape supports complex parameters given as JSON-formatted strings using the special `type: JSON` declaration. JSON objects and arrays of objects are accepted equally, with nested validation rules applied to all objects in either case: ```ruby params do requires :json, type: JSON do requires :int, type: Integer, values: [1, 2, 3] end end get '/' do params[:json].inspect end # ... client.get('/', json: '{"int":1}') # => "{:int=>1}" client.get('/', json: '[{"int":"1"}]') # => "[{:int=>1}]" client.get('/', json: '{"int":4}') # => HTTP 400 client.get('/', json: '[{"int":4}]') # => HTTP 400 ``` Additionally `type: Array[JSON]` may be used, which explicitly marks the parameter as an array of objects. If a single object is supplied it will be wrapped. ```ruby params do requires :json, type: Array[JSON] do requires :int, type: Integer end end get '/' do params[:json].each { |obj| ... } # always works end ``` For stricter control over the type of JSON structure which may be supplied, use `type: Array, coerce_with: JSON` or `type: Hash, coerce_with: JSON`. ### Multiple Allowed Types Variant-type parameters can be declared using the `types` option rather than `type`: ```ruby params do requires :status_code, types: [Integer, String, Array[Integer, String]] end get '/' do params[:status_code].inspect end # ... client.get('/', status_code: 'OK_GOOD') # => "OK_GOOD" client.get('/', status_code: 300) # => 300 client.get('/', status_code: %w(404 NOT FOUND)) # => [404, "NOT", "FOUND"] ``` As a special case, variant-member-type collections may also be declared, by passing a `Set` or `Array` with more than one member to `type`: ```ruby params do requires :status_codes, type: Array[Integer,String] end get '/' do params[:status_codes].inspect end # ... client.get('/', status_codes: %w(1 two)) # => [1, "two"] ``` ### Validation of Nested Parameters Parameters can be nested using `group` or by calling `requires` or `optional` with a block. In the above example, this means `params[:media][:url]` is required along with `params[:id]`, and `params[:audio][:format]` is required only if `params[:audio]` is present. With a block, `group`, `requires` and `optional` accept an additional option `type` which can be either `Array` or `Hash`, and defaults to `Array`. Depending on the value, the nested parameters will be treated either as values of a hash or as values of hashes in an array. ```ruby params do optional :preferences, type: Array do requires :key requires :value end requires :name, type: Hash do requires :first_name requires :last_name end end ``` ### Dependent Parameters Suppose some of your parameters are only relevant if another parameter is given; Grape allows you to express this relationship through the `given` method in your parameters block, like so: ```ruby params do optional :shelf_id, type: Integer given :shelf_id do requires :bin_id, type: Integer end end ``` ### Built-in Validators #### `allow_blank` Parameters can be defined as `allow_blank`, ensuring that they contain a value. By default, `requires` only validates that a parameter was sent in the request, regardless its value. With `allow_blank: false`, empty values or whitespace only values are invalid. `allow_blank` can be combined with both `requires` and `optional`. If the parameter is required, it has to contain a value. If it's optional, it's possible to not send it in the request, but if it's being sent, it has to have some value, and not an empty string/only whitespaces. ```ruby params do requires :username, allow_blank: false optional :first_name, allow_blank: false end ``` #### `values` Parameters can be restricted to a specific set of values with the `:values` option. Default values are eagerly evaluated. Above `:non_random_number` will evaluate to the same number for each call to the endpoint of this `params` block. To have the default evaluate lazily with each request use a lambda, like `:random_number` above. ```ruby params do requires :status, type: Symbol, values: [:not_started, :processing, :done] optional :numbers, type: Array[Integer], default: 1, values: [1, 2, 3, 5, 8] end ``` Supplying a range to the `:values` option ensures that the parameter is (or parameters are) included in that range (using `Range#include?`). ```ruby params do requires :latitude, type: Float, values: -90.0..+90.0 requires :longitude, type: Float, values: -180.0..+180.0 optional :letters, type: Array[String], values: 'a'..'z' end ``` Note that *both* range endpoints have to be a `#kind_of?` your `:type` option (if you don't supplied the `:type` option, it will be guessed to be equal to the class of the range's first endpoint). So the following is invalid: ```ruby params do requires :invalid1, type: Float, values: 0..10 # 0.kind_of?(Float) => false optional :invalid2, values: 0..10.0 # 10.0.kind_of?(0.class) => false end ``` The `:values` option can also be supplied with a `Proc`, evaluated lazily with each request. For example, given a status model you may want to restrict by hashtags that you have previously defined in the `HashTag` model. ```ruby params do requires :hashtag, type: String, values: -> { Hashtag.all.map(&:tag) } end ``` #### `regexp` Parameters can be restricted to match a specific regular expression with the `:regexp` option. If the value does not match the regular expression an error will be returned. Note that this is true for both `requires` and `optional` parameters. ```ruby params do requires :email, regexp: /.+@.+/ end ``` The validator will pass if the parameter was sent without value. To ensure that the parameter contains a value, use `allow_blank: false`. ```ruby params do requires :email, allow_blank: false, regexp: /.+@.+/ end ``` #### `mutually_exclusive` Parameters can be defined as `mutually_exclusive`, ensuring that they aren't present at the same time in a request. ```ruby params do optional :beer optional :wine mutually_exclusive :beer, :wine end ``` Multiple sets can be defined: ```ruby params do optional :beer optional :wine mutually_exclusive :beer, :wine optional :scotch optional :aquavit mutually_exclusive :scotch, :aquavit end ``` **Warning**: Never define mutually exclusive sets with any required params. Two mutually exclusive required params will mean params are never valid, thus making the endpoint useless. One required param mutually exclusive with an optional param will mean the latter is never valid. #### `exactly_one_of` Parameters can be defined as 'exactly_one_of', ensuring that exactly one parameter gets selected. ```ruby params do optional :beer optional :wine exactly_one_of :beer, :wine end ``` #### `at_least_one_of` Parameters can be defined as 'at_least_one_of', ensuring that at least one parameter gets selected. ```ruby params do optional :beer optional :wine optional :juice at_least_one_of :beer, :wine, :juice end ``` #### `all_or_none_of` Parameters can be defined as 'all_or_none_of', ensuring that all or none of parameters gets selected. ```ruby params do optional :beer optional :wine optional :juice all_or_none_of :beer, :wine, :juice end ``` #### Nested `mutually_exclusive`, `exactly_one_of`, `at_least_one_of`, `all_or_none_of` All of these methods can be used at any nested level. ```ruby params do requires :food do optional :meat optional :fish optional :rice at_least_one_of :meat, :fish, :rice end group :drink do optional :beer optional :wine optional :juice exactly_one_of :beer, :wine, :juice end optional :dessert do optional :cake optional :icecream mutually_exclusive :cake, :icecream end optional :recipe do optional :oil optional :meat all_or_none_of :oil, :meat end end ``` ### Namespace Validation and Coercion Namespaces allow parameter definitions and apply to every method within the namespace. ```ruby namespace :statuses do params do requires :user_id, type: Integer, desc: 'A user ID.' end namespace ':user_id' do desc "Retrieve a user's status." params do requires :status_id, type: Integer, desc: 'A status ID.' end get ':status_id' do User.find(params[:user_id]).statuses.find(params[:status_id]) end end end ``` The `namespace` method has a number of aliases, including: `group`, `resource`, `resources`, and `segment`. Use whichever reads the best for your API. You can conveniently define a route parameter as a namespace using `route_param`. ```ruby namespace :statuses do route_param :id do desc 'Returns all replies for a status.' get 'replies' do Status.find(params[:id]).replies end desc 'Returns a status.' get do Status.find(params[:id]) end end end ``` You can also define a route parameter type by passing to `route_param`'s options. ```ruby namespace :arithmetic do route_param :n, type: Integer do desc 'Returns in power' get 'power' do params[:n] ** params[:n] end end end ``` ### Custom Validators ```ruby class AlphaNumeric < Grape::Validations::Base def validate_param!(attr_name, params) unless params[attr_name] =~ /\A[[:alnum:]]+\z/ fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: 'must consist of alpha-numeric characters' end end end ``` ```ruby params do requires :text, alpha_numeric: true end ``` You can also create custom classes that take parameters. ```ruby class Length < Grape::Validations::Base def validate_param!(attr_name, params) unless params[attr_name].length <= @option fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long" end end end ``` ```ruby params do requires :text, length: 140 end ``` You can also create custom validation that use request to validate the attribute. For example if you want to have parameters that are available to only admins, you can do the following. ```ruby class Admin < Grape::Validations::Base def validate(request) # return if the param we are checking was not in request # @attrs is a list containing the attribute we are currently validating # in our sample case this method once will get called with # @attrs being [:admin_field] and once with @attrs being [:admin_false_field] return unless request.params.key? @attrs.first # check if admin flag is set to true return unless @option # check if user is admin or not # as an example get a token from request and check if it's admin or not fail Grape::Exceptions::Validation, params: @attrs, message: 'Can not set admin-only field.' unless request.headers['X-Access-Token'] == 'admin' end end ``` And use it in your endpoint definition as: ```ruby params do optional :admin_field, type: String, admin: true optional :non_admin_field, type: String optional :admin_false_field, type: String, admin: false end ``` ### Validation Errors Validation and coercion errors are collected and an exception of type `Grape::Exceptions::ValidationErrors` is raised. If the exception goes uncaught it will respond with a status of 400 and an error message. The validation errors are grouped by parameter name and can be accessed via `Grape::Exceptions::ValidationErrors#errors`. The default response from a `Grape::Exceptions::ValidationErrors` is a humanly readable string, such as "beer, wine are mutually exclusive", in the following example. ```ruby params do optional :beer optional :wine optional :juice exactly_one_of :beer, :wine, :juice end ``` You can rescue a `Grape::Exceptions::ValidationErrors` and respond with a custom response or turn the response into well-formatted JSON for a JSON API that separates individual parameters and the corresponding error messages. The following `rescue_from` example produces `[{"params":["beer","wine"],"messages":["are mutually exclusive"]}]`. ```ruby format :json subject.rescue_from Grape::Exceptions::ValidationErrors do |e| error! e, 400 end ``` `Grape::Exceptions::ValidationErrors#full_messages` returns the validation messages as an array. `Grape::Exceptions::ValidationErrors#message` joins the messages to one string. For responding with an array of validation messages, you can use `Grape::Exceptions::ValidationErrors#full_messages`. ```ruby format :json subject.rescue_from Grape::Exceptions::ValidationErrors do |e| error!({ messages: e.full_messages }, 400) end ``` ### I18n Grape supports I18n for parameter-related error messages, but will fallback to English if translations for the default locale have not been provided. See [en.yml](lib/grape/locale/en.yml) for message keys. ### Custom Validation messages Grape supports custom validation messages for parameter-related and coerce-related error messages. #### `presence`, `allow_blank`, `values`, `regexp` ```ruby params do requires :name, values: { value: 1..10, message: 'not in range from 1 to 10' }, allow_blank: { value: false, message: 'cannot be blank' }, regexp: { value: /^[a-z]+$/, message: 'format is invalid' }, message: 'is required' end ``` #### `all_or_none_of` ```ruby params do optional :beer optional :wine optional :juice all_or_none_of :beer, :wine, :juice, message: "all params are required or none is required" end ``` #### `mutually_exclusive` ```ruby params do optional :beer optional :wine optional :juice mutually_exclusive :beer, :wine, :juice, message: "are mutually exclusive cannot pass both params" end ``` #### `exactly_one_of` ```ruby params do optional :beer optional :wine optional :juice exactly_one_of :beer, :wine, :juice, message: {exactly_one: "are missing, exactly one parameter is required", mutual_exclusion: "are mutually exclusive, exactly one parameter is required"} end ``` #### `at_least_one_of` ```ruby params do optional :beer optional :wine optional :juice at_least_one_of :beer, :wine, :juice, message: "are missing, please specify at least one param" end ``` #### `Coerce` ```ruby params do requires :int, type: {value: Integer, message: "type cast is invalid" } end ``` #### `With Lambdas` ```ruby params do requires :name, values: { value: -> { (1..10).to_a }, message: 'not in range from 1 to 10' } end ``` #### `Pass symbols for i18n translations` You can pass a symbol if you want i18n translations for your custom validation messages. ```ruby params do requires :name, message: :name_required end ``` ```ruby # en.yml en: grape: errors: format: ! '%{attributes} %{message}' messages: name_required: 'must be present' ``` #### `Overriding attribute names` You can also override attribute names. ```ruby # en.yml en: grape: errors: format: ! '%{attributes} %{message}' messages: name_required: 'must be present' attributes: name: 'Oops! Name' ``` Will produce 'Oops! Name must be present' #### `With Default` You cannot set a custom message option for Default as it requires interpolation `%{option1}: %{value1} is incompatible with %{option2}: %{value2}`. You can change the default error message for Default by changing the `incompatible_option_values` message key inside [en.yml](lib/grape/locale/en.yml) ```ruby params do requires :name, values: { value: -> { (1..10).to_a }, message: 'not in range from 1 to 10' }, default: 5 end ``` ## Headers Request headers are available through the `headers` helper or from `env` in their original form. ```ruby get do error!('Unauthorized', 401) unless headers['Secret-Password'] == 'swordfish' end ``` ```ruby get do error!('Unauthorized', 401) unless env['HTTP_SECRET_PASSWORD'] == 'swordfish' end ``` You can set a response header with `header` inside an API. ```ruby header 'X-Robots-Tag', 'noindex' ``` When raising `error!`, pass additional headers as arguments. ```ruby error! 'Unauthorized', 401, 'X-Error-Detail' => 'Invalid token.' ``` ## Routes Optionally, you can define requirements for your named route parameters using regular expressions on namespace or endpoint. The route will match only if all requirements are met. ```ruby get ':id', requirements: { id: /[0-9]*/ } do Status.find(params[:id]) end namespace :outer, requirements: { id: /[0-9]*/ } do get :id do end get ':id/edit' do end end ``` ## Helpers You can define helper methods that your endpoints can use with the `helpers` macro by either giving a block or a module. ```ruby module StatusHelpers def user_info(user) "#{user} has statused #{user.statuses} status(s)" end end class API < Grape::API # define helpers with a block helpers do def current_user User.find(params[:user_id]) end end # or mix in a module helpers StatusHelpers get 'info' do # helpers available in your endpoint and filters user_info(current_user) end end ``` You can define reusable `params` using `helpers`. ```ruby class API < Grape::API helpers do params :pagination do optional :page, type: Integer optional :per_page, type: Integer end end desc 'Get collection' params do use :pagination # aliases: includes, use_scope end get do Collection.page(params[:page]).per(params[:per_page]) end end ``` You can also define reusable `params` using shared helpers. ```ruby module SharedParams extend Grape::API::Helpers params :period do optional :start_date optional :end_date end params :pagination do optional :page, type: Integer optional :per_page, type: Integer end end class API < Grape::API helpers SharedParams desc 'Get collection.' params do use :period, :pagination end get do Collection .from(params[:start_date]) .to(params[:end_date]) .page(params[:page]) .per(params[:per_page]) end end ``` Helpers support blocks that can help set default values. The following API can return a collection sorted by `id` or `created_at` in `asc` or `desc` order. ```ruby module SharedParams extend Grape::API::Helpers params :order do |options| optional :order_by, type:Symbol, values:options[:order_by], default:options[:default_order_by] optional :order, type:Symbol, values:%i(asc desc), default:options[:default_order] end end class API < Grape::API helpers SharedParams desc 'Get a sorted collection.' params do use :order, order_by:%i(id created_at), default_order_by: :created_at, default_order: :asc end get do Collection.send(params[:order], params[:order_by]) end end ``` ## Path Helpers If you need methods for generating paths inside your endpoints, please see the [grape-route-helpers](https://github.com/reprah/grape-route-helpers) gem. ## Parameter Documentation You can attach additional documentation to `params` using a `documentation` hash. ```ruby params do optional :first_name, type: String, documentation: { example: 'Jim' } requires :last_name, type: String, documentation: { example: 'Smith' } end ``` ## Cookies You can set, get and delete your cookies very simply using `cookies` method. ```ruby class API < Grape::API get 'status_count' do cookies[:status_count] ||= 0 cookies[:status_count] += 1 { status_count: cookies[:status_count] } end delete 'status_count' do { status_count: cookies.delete(:status_count) } end end ``` Use a hash-based syntax to set more than one value. ```ruby cookies[:status_count] = { value: 0, expires: Time.tomorrow, domain: '.twitter.com', path: '/' } cookies[:status_count][:value] +=1 ``` Delete a cookie with `delete`. ```ruby cookies.delete :status_count ``` Specify an optional path. ```ruby cookies.delete :status_count, path: '/' ``` ## HTTP Status Code By default Grape returns a 200 status code for `GET`-Requests and 201 for `POST`-Requests. You can use `status` to query and set the actual HTTP Status Code ```ruby post do status 202 if status == 200 # do some thing end end ``` You can also use one of status codes symbols that are provided by [Rack utils](http://www.rubydoc.info/github/rack/rack/Rack/Utils#HTTP_STATUS_CODES-constant) ```ruby post do status :no_content end ``` ## Redirecting You can redirect to a new url temporarily (302) or permanently (301). ```ruby redirect '/statuses' ``` ```ruby redirect '/statuses', permanent: true ``` ## Recognizing Path You can recognize the endpoint matched with given path. This API returns an instance of `Grape::Endpoint`. ```ruby class API < Grape::API get '/statuses' do end end API.recognize_path '/statuses' ``` ## Allowed Methods When you add a `GET` route for a resource, a route for the `HEAD` method will also be added automatically. You can disable this behavior with `do_not_route_head!`. ``` ruby class API < Grape::API do_not_route_head! get '/example' do # only responds to GET end end ``` When you add a route for a resource, a route for the `OPTIONS` method will also be added. The response to an OPTIONS request will include an "Allow" header listing the supported methods. ```ruby class API < Grape::API get '/rt_count' do { rt_count: current_user.rt_count } end params do requires :value, type: Integer, desc: 'Value to add to the rt count.' end put '/rt_count' do current_user.rt_count += params[:value].to_i { rt_count: current_user.rt_count } end end ``` ``` shell curl -v -X OPTIONS http://localhost:3000/rt_count > OPTIONS /rt_count HTTP/1.1 > < HTTP/1.1 204 No Content < Allow: OPTIONS, GET, PUT ``` You can disable this behavior with `do_not_route_options!`. If a request for a resource is made with an unsupported HTTP method, an HTTP 405 (Method Not Allowed) response will be returned. ``` shell curl -X DELETE -v http://localhost:3000/rt_count/ > DELETE /rt_count/ HTTP/1.1 > Host: localhost:3000 > < HTTP/1.1 405 Method Not Allowed < Allow: OPTIONS, GET, PUT ``` ## Raising Exceptions You can abort the execution of an API method by raising errors with `error!`. ```ruby error! 'Access Denied', 401 ``` Anything that responds to `#to_s` can be given as a first argument to `error!`. ```ruby error! :not_found, 404 ``` You can also return JSON formatted objects by raising error! and passing a hash instead of a message. ```ruby error!({ error: 'unexpected error', detail: 'missing widget' }, 500) ``` You can present documented errors with a Grape entity using the the [grape-entity](https://github.com/ruby-grape/grape-entity) gem. ```ruby module API class Error < Grape::Entity expose :code expose :message end end ``` The following example specifies the entity to use in the `http_codes` definition. ```ruby desc 'My Route' do failure [[408, 'Unauthorized', API::Error]] end error!({ message: 'Unauthorized' }, 408) ``` The following example specifies the presented entity explicitly in the error message. ```ruby desc 'My Route' do failure [[408, 'Unauthorized']] end error!({ message: 'Unauthorized', with: API::Error }, 408) ``` ### Default Error HTTP Status Code By default Grape returns a 500 status code from `error!`. You can change this with `default_error_status`. ``` ruby class API < Grape::API default_error_status 400 get '/example' do error! 'This should have http status code 400' end end ``` ### Handling 404 For Grape to handle all the 404s for your API, it can be useful to use a catch-all. In its simplest form, it can be like: ```ruby route :any, '*path' do error! # or something else end ``` It is very crucial to __define this endpoint at the very end of your API__, as it literally accepts every request. ## Exception Handling Grape can be told to rescue all exceptions and return them in the API format. ```ruby class Twitter::API < Grape::API rescue_from :all end ``` You can also rescue specific exceptions. ```ruby class Twitter::API < Grape::API rescue_from ArgumentError, UserDefinedError end ``` In this case ```UserDefinedError``` must be inherited from ```StandardError```. The error format will match the request format. See "Content-Types" below. Custom error formatters for existing and additional types can be defined with a proc. ```ruby class Twitter::API < Grape::API error_formatter :txt, ->(message, backtrace, options, env) { "error: #{message} from #{backtrace}" } end ``` You can also use a module or class. ```ruby module CustomFormatter def self.call(message, backtrace, options, env) { message: message, backtrace: backtrace } end end class Twitter::API < Grape::API error_formatter :custom, CustomFormatter end ``` You can rescue all exceptions with a code block. The `error!` wrapper automatically sets the default error code and content-type. ```ruby class Twitter::API < Grape::API rescue_from :all do |e| error!("rescued from #{e.class.name}") end end ``` Optionally, you can set the format, status code and headers. ```ruby class Twitter::API < Grape::API format :json rescue_from :all do |e| error!({ error: 'Server error.' }, 500, { 'Content-Type' => 'text/error' }) end end ``` You can also rescue specific exceptions with a code block and handle the Rack response at the lowest level. ```ruby class Twitter::API < Grape::API rescue_from :all do |e| Rack::Response.new([ e.message ], 500, { 'Content-type' => 'text/error' }).finish end end ``` Or rescue specific exceptions. ```ruby class Twitter::API < Grape::API rescue_from ArgumentError do |e| error!("ArgumentError: #{e.message}") end rescue_from NotImplementedError do |e| error!("NotImplementedError: #{e.message}") end end ``` By default, `rescue_from` will rescue the exceptions listed and all their subclasses. Assume you have the following exception classes defined. ```ruby module APIErrors class ParentError < StandardError; end class ChildError < ParentError; end end ``` Then the following `rescue_from` clause will rescue exceptions of type `APIErrors::ParentError` and its subclasses (in this case `APIErrors::ChildError`). ```ruby rescue_from APIErrors::ParentError do |e| error!({ error: "#{e.class} error", message: e.message }, e.status) end ``` To only rescue the base exception class, set `rescue_subclasses: false`. The code below will rescue exceptions of type `RuntimeError` but _not_ its subclasses. ```ruby rescue_from RuntimeError, rescue_subclasses: false do |e| error!({ status: e.status, message: e.message, errors: e.errors }, e.status) end ``` Helpers are also available inside `rescue_from`. ```ruby class Twitter::API < Grape::API format :json helpers do def server_error! error!({ error: 'Server error.' }, 500, { 'Content-Type' => 'text/error' }) end end rescue_from :all do |e| server_error! end end ``` The `rescue_from` block must return a `Rack::Response` object, call `error!` or re-raise an exception. The `with` keyword is available as `rescue_from` options, it can be passed method name or Proc object. ```ruby class Twitter::API < Grape::API format :json helpers do def server_error! error!({ error: 'Server error.' }, 500, { 'Content-Type' => 'text/error' }) end end rescue_from :all, with: :server_error! rescue_from ArgumentError, with: -> { Rack::Response.new('rescued with a method', 400) } end ``` #### Unrescuable Exceptions `Grape::Exceptions::InvalidVersionHeader`, which is raised when the version in the request header doesn't match the currently evaluated version for the endpoint, will _never_ be rescued from a `rescue_from` block (even a `rescue_from :all`) This is because Grape relies on Rack to catch that error and try the next versioned-route for cases where there exist identical Grape endpoints with different versions. ### Rails 3.x When mounted inside containers, such as Rails 3.x, errors such as "404 Not Found" or "406 Not Acceptable" will likely be handled and rendered by Rails handlers. For instance, accessing a nonexistent route "/api/foo" raises a 404, which inside rails will ultimately be translated to an `ActionController::RoutingError`, which most likely will get rendered to a HTML error page. Most APIs will enjoy preventing downstream handlers from handling errors. You may set the `:cascade` option to `false` for the entire API or separately on specific `version` definitions, which will remove the `X-Cascade: true` header from API responses. ```ruby cascade false ``` ```ruby version 'v1', using: :header, vendor: 'twitter', cascade: false ``` ## Logging `Grape::API` provides a `logger` method which by default will return an instance of the `Logger` class from Ruby's standard library. To log messages from within an endpoint, you need to define a helper to make the logger available in the endpoint context. ```ruby class API < Grape::API helpers do def logger API.logger end end post '/statuses' do # ... logger.info "#{current_user} has statused" end end ``` You can also set your own logger. ```ruby class MyLogger def warning(message) puts "this is a warning: #{message}" end end class API < Grape::API logger MyLogger.new helpers do def logger API.logger end end get '/statuses' do logger.warning "#{current_user} has statused" end end ``` For similar to Rails request logging try the [grape_logging](https://github.com/aserafin/grape_logging) or [grape-middleware-logger](https://github.com/ridiculous/grape-middleware-logger) gems. ## API Formats Your API can declare which content-types to support by using `content_type`. If you do not specify any, Grape will support _XML_, _JSON_, _BINARY_, and _TXT_ content-types. The default format is `:txt`; you can change this with `default_format`. Essentially, the two APIs below are equivalent. ```ruby class Twitter::API < Grape::API # no content_type declarations, so Grape uses the defaults end class Twitter::API < Grape::API # the following declarations are equivalent to the defaults content_type :xml, 'application/xml' content_type :json, 'application/json' content_type :binary, 'application/octet-stream' content_type :txt, 'text/plain' default_format :txt end ``` If you declare any `content_type` whatsoever, the Grape defaults will be overridden. For example, the following API will only support the `:xml` and `:rss` content-types, but not `:txt`, `:json`, or `:binary`. Importantly, this means the `:txt` default format is not supported! So, make sure to set a new `default_format`. ```ruby class Twitter::API < Grape::API content_type :xml, 'application/xml' content_type :rss, 'application/xml+rss' default_format :xml end ``` Serialization takes place automatically. For example, you do not have to call `to_json` in each JSON API endpoint implementation. The response format (and thus the automatic serialization) is determined in the following order: * Use the file extension, if specified. If the file is .json, choose the JSON format. * Use the value of the `format` parameter in the query string, if specified. * Use the format set by the `format` option, if specified. * Attempt to find an acceptable format from the `Accept` header. * Use the default format, if specified by the `default_format` option. * Default to `:txt`. For example, consider the following API. ```ruby class MultipleFormatAPI < Grape::API content_type :xml, 'application/xml' content_type :json, 'application/json' default_format :json get :hello do { hello: 'world' } end end ``` * `GET /hello` (with an `Accept: */*` header) does not have an extension or a `format` parameter, so it will respond with JSON (the default format). * `GET /hello.xml` has a recognized extension, so it will respond with XML. * `GET /hello?format=xml` has a recognized `format` parameter, so it will respond with XML. * `GET /hello.xml?format=json` has a recognized extension (which takes precedence over the `format` parameter), so it will respond with XML. * `GET /hello.xls` (with an `Accept: */*` header) has an extension, but that extension is not recognized, so it will respond with JSON (the default format). * `GET /hello.xls` with an `Accept: application/xml` header has an unrecognized extension, but the `Accept` header corresponds to a recognized format, so it will respond with XML. * `GET /hello.xls` with an `Accept: text/plain` header has an unrecognized extension *and* an unrecognized `Accept` header, so it will respond with JSON (the default format). You can override this process explicitly by specifying `env['api.format']` in the API itself. For example, the following API will let you upload arbitrary files and return their contents as an attachment with the correct MIME type. ```ruby class Twitter::API < Grape::API post 'attachment' do filename = params[:file][:filename] content_type MIME::Types.type_for(filename)[0].to_s env['api.format'] = :binary # there's no formatter for :binary, data will be returned "as is" header 'Content-Disposition', "attachment; filename*=UTF-8''#{CGI.escape(filename)}" params[:file][:tempfile].read end end ``` You can have your API only respond to a single format with `format`. If you use this, the API will **not** respond to file extensions other than specified in `format`. For example, consider the following API. ```ruby class SingleFormatAPI < Grape::API format :json get :hello do { hello: 'world' } end end ``` * `GET /hello` will respond with JSON. * `GET /hello.json` will respond with JSON. * `GET /hello.xml`, `GET /hello.foobar`, or *any* other extension will respond with an HTTP 404 error code. * `GET /hello?format=xml` will respond with an HTTP 406 error code, because the XML format specified by the request parameter is not supported. * `GET /hello` with an `Accept: application/xml` header will still respond with JSON, since it could not negotiate a recognized content-type from the headers and JSON is the effective default. The formats apply to parsing, too. The following API will only respond to the JSON content-type and will not parse any other input than `application/json`, `application/x-www-form-urlencoded`, `multipart/form-data`, `multipart/related` and `multipart/mixed`. All other requests will fail with an HTTP 406 error code. ```ruby class Twitter::API < Grape::API format :json end ``` When the content-type is omitted, Grape will return a 406 error code unless `default_format` is specified. The following API will try to parse any data without a content-type using a JSON parser. ```ruby class Twitter::API < Grape::API format :json default_format :json end ``` If you combine `format` with `rescue_from :all`, errors will be rendered using the same format. If you do not want this behavior, set the default error formatter with `default_error_formatter`. ```ruby class Twitter::API < Grape::API format :json content_type :txt, 'text/plain' default_error_formatter :txt end ``` Custom formatters for existing and additional types can be defined with a proc. ```ruby class Twitter::API < Grape::API content_type :xls, 'application/vnd.ms-excel' formatter :xls, ->(object, env) { object.to_xls } end ``` You can also use a module or class. ```ruby module XlsFormatter def self.call(object, env) object.to_xls end end class Twitter::API < Grape::API content_type :xls, 'application/vnd.ms-excel' formatter :xls, XlsFormatter end ``` Built-in formatters are the following. * `:json`: use object's `to_json` when available, otherwise call `MultiJson.dump` * `:xml`: use object's `to_xml` when available, usually via `MultiXml`, otherwise call `to_s` * `:txt`: use object's `to_txt` when available, otherwise `to_s` * `:serializable_hash`: use object's `serializable_hash` when available, otherwise fallback to `:json` * `:binary`: data will be returned "as is" Response statuses that indicate no content as defined by [Rack](https://github.com/rack) [here](https://github.com/rack/rack/blob/master/lib/rack/utils.rb#L567) will bypass serialization and the body entity - though there should be none - will not be modified. ### JSONP Grape supports JSONP via [Rack::JSONP](https://github.com/rack/rack-contrib), part of the [rack-contrib](https://github.com/rack/rack-contrib) gem. Add `rack-contrib` to your `Gemfile`. ```ruby require 'rack/contrib' class API < Grape::API use Rack::JSONP format :json get '/' do 'Hello World' end end ``` ### CORS Grape supports CORS via [Rack::CORS](https://github.com/cyu/rack-cors), part of the [rack-cors](https://github.com/cyu/rack-cors) gem. Add `rack-cors` to your `Gemfile`, then use the middleware in your config.ru file. ```ruby require 'rack/cors' use Rack::Cors do allow do origins '*' resource '*', headers: :any, methods: :get end end run Twitter::API ``` ## Content-type Content-type is set by the formatter. You can override the content-type of the response at runtime by setting the `Content-Type` header. ```ruby class API < Grape::API get '/home_timeline_js' do content_type 'application/javascript' "var statuses = ...;" end end ``` ## API Data Formats Grape accepts and parses input data sent with the POST and PUT methods as described in the Parameters section above. It also supports custom data formats. You must declare additional content-types via `content_type` and optionally supply a parser via `parser` unless a parser is already available within Grape to enable a custom format. Such a parser can be a function or a class. With a parser, parsed data is available "as-is" in `env['api.request.body']`. Without a parser, data is available "as-is" and in `env['api.request.input']`. The following example is a trivial parser that will assign any input with the "text/custom" content-type to `:value`. The parameter will be available via `params[:value]` inside the API call. ```ruby module CustomParser def self.call(object, env) { value: object.to_s } end end ``` ```ruby content_type :txt, 'text/plain' content_type :custom, 'text/custom' parser :custom, CustomParser put 'value' do params[:value] end ``` You can invoke the above API as follows. ``` curl -X PUT -d 'data' 'http://localhost:9292/value' -H Content-Type:text/custom -v ``` You can disable parsing for a content-type with `nil`. For example, `parser :json, nil` will disable JSON parsing altogether. The request data is then available as-is in `env['api.request.body']`. ## RESTful Model Representations Grape supports a range of ways to present your data with some help from a generic `present` method, which accepts two arguments: the object to be presented and the options associated with it. The options hash may include `:with`, which defines the entity to expose. ### Grape Entities Add the [grape-entity](https://github.com/ruby-grape/grape-entity) gem to your Gemfile. Please refer to the [grape-entity documentation](https://github.com/ruby-grape/grape-entity/blob/master/README.md) for more details. The following example exposes statuses. ```ruby module API module Entities class Status < Grape::Entity expose :user_name expose :text, documentation: { type: 'string', desc: 'Status update text.' } expose :ip, if: { type: :full } expose :user_type, :user_id, if: ->(status, options) { status.user.public? } expose :digest do |status, options| Digest::MD5.hexdigest(status.txt) end expose :replies, using: API::Status, as: :replies end end class Statuses < Grape::API version 'v1' desc 'Statuses index' do params: API::Entities::Status.documentation end get '/statuses' do statuses = Status.all type = current_user.admin? ? :full : :default present statuses, with: API::Entities::Status, type: type end end end ``` You can use entity documentation directly in the params block with `using: Entity.documentation`. ```ruby module API class Statuses < Grape::API version 'v1' desc 'Create a status' params do requires :all, except: [:ip], using: API::Entities::Status.documentation.except(:id) end post '/status' do Status.create! params end end end ``` You can present with multiple entities using an optional Symbol argument. ```ruby get '/statuses' do statuses = Status.all.page(1).per(20) present :total_page, 10 present :per_page, 20 present :statuses, statuses, with: API::Entities::Status end ``` The response will be ``` { total_page: 10, per_page: 20, statuses: [] } ``` In addition to separately organizing entities, it may be useful to put them as namespaced classes underneath the model they represent. ```ruby class Status def entity Entity.new(self) end class Entity < Grape::Entity expose :text, :user_id end end ``` If you organize your entities this way, Grape will automatically detect the `Entity` class and use it to present your models. In this example, if you added `present Status.new` to your endpoint, Grape will automatically detect that there is a `Status::Entity` class and use that as the representative entity. This can still be overridden by using the `:with` option or an explicit `represents` call. You can present `hash` with `Grape::Presenters::Presenter` to keep things consistent. ```ruby get '/users' do present { id: 10, name: :dgz }, with: Grape::Presenters::Presenter end ```` The response will be ```ruby { id: 10, name: 'dgz' } ``` It has the same result with ```ruby get '/users' do present :id, 10 present :name, :dgz end ``` ### Hypermedia and Roar You can use [Roar](https://github.com/apotonick/roar) to render HAL or Collection+JSON with the help of [grape-roar](https://github.com/ruby-grape/grape-roar), which defines a custom JSON formatter and enables presenting entities with Grape's `present` keyword. ### Rabl You can use [Rabl](https://github.com/nesquena/rabl) templates with the help of the [grape-rabl](https://github.com/ruby-grape/grape-rabl) gem, which defines a custom Grape Rabl formatter. ### Active Model Serializers You can use [Active Model Serializers](https://github.com/rails-api/active_model_serializers) serializers with the help of the [grape-active_model_serializers](https://github.com/jrhe/grape-active_model_serializers) gem, which defines a custom Grape AMS formatter. ## Sending Raw or No Data In general, use the binary format to send raw data. ```ruby class API < Grape::API get '/file' do content_type 'application/octet-stream' File.binread 'file.bin' end end ``` You can set the response body explicitly with `body`. ```ruby class API < Grape::API get '/' do content_type 'text/plain' body 'Hello World' # return value ignored end end ``` Use `body false` to return `204 No Content` without any data or content-type. You can also set the response to a file with `file`. ```ruby class API < Grape::API get '/' do file '/path/to/file' end end ``` If you want a file to be streamed using Rack::Chunked, use `stream`. ```ruby class API < Grape::API get '/' do stream '/path/to/file' end end ``` ## Authentication ### Basic and Digest Auth Grape has built-in Basic and Digest authentication (the given `block` is executed in the context of the current `Endpoint`). Authentication applies to the current namespace and any children, but not parents. ```ruby http_basic do |username, password| # verify user's password here { 'test' => 'password1' }[username] == password end ``` ```ruby http_digest({ realm: 'Test Api', opaque: 'app secret' }) do |username| # lookup the user's password here { 'user1' => 'password1' }[username] end ``` ### Register custom middleware for authentication Grape can use custom Middleware for authentication. How to implement these Middleware have a look at `Rack::Auth::Basic` or similar implementations. For registering a Middleware you need the following options: * `label` - the name for your authenticator to use it later * `MiddlewareClass` - the MiddlewareClass to use for authentication * `option_lookup_proc` - A Proc with one Argument to lookup the options at runtime (return value is an `Array` as Parameter for the Middleware). Example: ```ruby Grape::Middleware::Auth::Strategies.add(:my_auth, AuthMiddleware, ->(options) { [options[:realm]] } ) auth :my_auth, { realm: 'Test Api'} do |credentials| # lookup the user's password here { 'user1' => 'password1' }[username] end ``` Use [warden-oauth2](https://github.com/opperator/warden-oauth2) or [rack-oauth2](https://github.com/nov/rack-oauth2) for OAuth2 support. ## Describing and Inspecting an API Grape routes can be reflected at runtime. This can notably be useful for generating documentation. Grape exposes arrays of API versions and compiled routes. Each route contains a `route_prefix`, `route_version`, `route_namespace`, `route_method`, `route_path` and `route_params`. You can add custom route settings to the route metadata with `route_setting`. ```ruby class TwitterAPI < Grape::API version 'v1' desc 'Includes custom settings.' route_setting :custom, key: 'value' get do end end ``` Examine the routes at runtime. ```ruby TwitterAPI::versions # yields [ 'v1', 'v2' ] TwitterAPI::routes # yields an array of Grape::Route objects TwitterAPI::routes[0].version # => 'v1' TwitterAPI::routes[0].description # => 'Includes custom settings.' TwitterAPI::routes[0].settings[:custom] # => { key: 'value' } ``` Note that `Route#route_xyz` methods have been deprecated since 0.15.0. Please use `Route#xyz` instead. Note that difference of `Route#options` and `Route#settings`. The `options` can be referred from your route, it should be set by specifing key and value on verb methods such as `get`, `post` and `put`. The `settings` can also be referred from your route, but it should be set by specifing key and value on `route_setting`. ## Current Route and Endpoint It's possible to retrieve the information about the current route from within an API call with `route`. ```ruby class MyAPI < Grape::API desc 'Returns a description of a parameter.' params do requires :id, type: Integer, desc: 'Identity.' end get 'params/:id' do route.route_params[params[:id]] # yields the parameter description end end ``` The current endpoint responding to the request is `self` within the API block or `env['api.endpoint']` elsewhere. The endpoint has some interesting properties, such as `source` which gives you access to the original code block of the API implementation. This can be particularly useful for building a logger middleware. ```ruby class ApiLogger < Grape::Middleware::Base def before file = env['api.endpoint'].source.source_location[0] line = env['api.endpoint'].source.source_location[1] logger.debug "[api] #{file}:#{line}" end end ``` ## Before and After Blocks can be executed before or after every API call, using `before`, `after`, `before_validation` and `after_validation`. Before and after callbacks execute in the following order: 1. `before` 2. `before_validation` 3. _validations_ 4. `after_validation` 5. _the API call_ 6. `after` Steps 4, 5 and 6 only happen if validation succeeds. #### Examples Using a simple `before` block to set a header ```ruby before do header 'X-Robots-Tag', 'noindex' end ``` **Namespaces** Callbacks apply to each API call within and below the current namespace: ```ruby class MyAPI < Grape::API get '/' do "root - #{@blah}" end namespace :foo do before do @blah = 'blah' end get '/' do "root - foo - #{@blah}" end namespace :bar do get '/' do "root - foo - bar - #{@blah}" end end end end ``` The behaviour is then: ```bash GET / # 'root - ' GET /foo # 'root - foo - blah' GET /foo/bar # 'root - foo - bar - blah' ``` Params on a `namespace` (or whichever alias you are using) will also be available when using `before_validation` or `after_validation`: ```ruby class MyAPI < Grape::API params do requires :blah, type: Integer end resource ':blah' do after_validation do # if we reach this point validations will have passed @blah = declared(params, include_missing: false)[:blah] end get '/' do @blah.class end end end ``` The behaviour is then: ```bash GET /123 # 'Fixnum' GET /foo # 400 error - 'blah is invalid' ``` **Versioning** When a callback is defined within a version block, it's only called for the routes defined in that block. ```ruby class Test < Grape::API resource :foo do version 'v1', :using => :path do before do @output ||= 'v1-' end get '/' do @output += 'hello' end end version 'v2', :using => :path do before do @output ||= 'v2-' end get '/' do @output += 'hello' end end end end ``` The behaviour is then: ```bash GET /foo/v1 # 'v1-hello' GET /foo/v2 # 'v2-hello' ``` **Altering Responses** Using `present` in any callback allows you to add data to a response: ```ruby class MyAPI < Grape::API format :json after_validation do present :name, params[:name] if params[:name] end get '/greeting' do present :greeting, 'Hello!' end end ``` The behaviour is then: ```bash GET /greeting # {"greeting":"Hello!"} GET /greeting?name=Alan # {"name":"Alan","greeting":"Hello!"} ``` Instead of altering a response, you can also terminate and rewrite it from any callback using `error!`, including `after`. This will cause all subsequent steps in the process to not be called. **This includes the actual api call and any callbacks** ## Anchoring Grape by default anchors all request paths, which means that the request URL should match from start to end to match, otherwise a `404 Not Found` is returned. However, this is sometimes not what you want, because it is not always known upfront what can be expected from the call. This is because Rack-mount by default anchors requests to match from the start to the end, or not at all. Rails solves this problem by using a `anchor: false` option in your routes. In Grape this option can be used as well when a method is defined. For instance when your API needs to get part of an URL, for instance: ```ruby class TwitterAPI < Grape::API namespace :statuses do get '/(*:status)', anchor: false do end end end ``` This will match all paths starting with '/statuses/'. There is one caveat though: the `params[:status]` parameter only holds the first part of the request url. Luckily this can be circumvented by using the described above syntax for path specification and using the `PATH_INFO` Rack environment variable, using `env['PATH_INFO']`. This will hold everything that comes after the '/statuses/' part. ## Using Custom Middleware ### Grape Middleware You can make a custom middleware by using `Grape::Middleware::Base`. It's inherited from some grape official middlewares in fact. For example, you can write a middleware to log application exception. ```ruby class LoggingError < Grape::Middleware::Base def after return unless @app_response && @app_response[0] == 500 env['rack.logger'].error("Raised error on #{env['PATH_INFO']}") end end ``` Your middleware can overwrite application response as follows, except error case. ```ruby class Overwriter < Grape::Middleware::Base def after [200, { 'Content-Type' => 'text/plain' }, ['Overwrited.']] end end ``` ### Rails Middleware Note that when you're using Grape mounted on Rails you don't have to use Rails middleware because it's already included into your middleware stack. You only have to implement the helpers to access the specific `env` variable. ### Remote IP By default you can access remote IP with `request.ip`. This is the remote IP address implemented by Rack. Sometimes it is desirable to get the remote IP [Rails-style](http://stackoverflow.com/questions/10997005/whats-the-difference-between-request-remote-ip-and-request-ip-in-rails) with `ActionDispatch::RemoteIp`. Add `gem 'actionpack'` to your Gemfile and `require 'action_dispatch/middleware/remote_ip.rb'`. Use the middleware in your API and expose a `client_ip` helper. See [this documentation](http://api.rubyonrails.org/classes/ActionDispatch/RemoteIp.html) for additional options. ```ruby class API < Grape::API use ActionDispatch::RemoteIp helpers do def client_ip env['action_dispatch.remote_ip'].to_s end end get :remote_ip do { ip: client_ip } end end ``` ## Writing Tests ### Writing Tests with Rack Use `rack-test` and define your API as `app`. #### RSpec You can test a Grape API with RSpec by making HTTP requests and examining the response. ```ruby require 'spec_helper' describe Twitter::API do include Rack::Test::Methods def app Twitter::API end context 'GET /api/statuses/public_timeline' do it 'returns an empty array of statuses' do get '/api/statuses/public_timeline' expect(last_response.status).to eq(200) expect(JSON.parse(last_response.body)).to eq [] end end context 'GET /api/statuses/:id' do it 'returns a status by id' do status = Status.create! get "/api/statuses/#{status.id}" expect(last_response.body).to eq status.to_json end end end ``` There's no standard way of sending arrays of objects via an HTTP GET, so POST JSON data and specify the correct content-type. ```ruby describe Twitter::API do context 'POST /api/statuses' do it 'creates many statuses' do statuses = [{ text: '...' }, { text: '...'}] post '/api/statuses', statuses.to_json, 'CONTENT_TYPE' => 'application/json' expect(last_response.body).to eq 201 end end end ``` #### Airborne You can test with other RSpec-based frameworks, including [Airborne](https://github.com/brooklynDev/airborne), which uses `rack-test` to make requests. ```ruby require 'airborne' Airborne.configure do |config| config.rack_app = Twitter::API end describe Twitter::API do context 'GET /api/statuses/:id' do it 'returns a status by id' do status = Status.create! get "/api/statuses/#{status.id}" expect_json(status.as_json) end end end ``` #### MiniTest ```ruby require 'test_helper' class Twitter::APITest < MiniTest::Test include Rack::Test::Methods def app Twitter::API end def test_get_api_statuses_public_timeline_returns_an_empty_array_of_statuses get '/api/statuses/public_timeline' assert last_response.ok? assert_equal [], JSON.parse(last_response.body) end def test_get_api_statuses_id_returns_a_status_by_id status = Status.create! get "/api/statuses/#{status.id}" assert_equal status.to_json, last_response.body end end ``` ### Writing Tests with Rails #### RSpec ```ruby describe Twitter::API do context 'GET /api/statuses/public_timeline' do it 'returns an empty array of statuses' do get '/api/statuses/public_timeline' expect(response.status).to eq(200) expect(JSON.parse(response.body)).to eq [] end end context 'GET /api/statuses/:id' do it 'returns a status by id' do status = Status.create! get "/api/statuses/#{status.id}" expect(response.body).to eq status.to_json end end end ``` In Rails, HTTP request tests would go into the `spec/requests` group. You may want your API code to go into `app/api` - you can match that layout under `spec` by adding the following in `spec/rails_helper.rb`. ```ruby RSpec.configure do |config| config.include RSpec::Rails::RequestExampleGroup, type: :request, file_path: /spec\/api/ end ``` #### MiniTest ```ruby class Twitter::APITest < ActiveSupport::TestCase include Rack::Test::Methods def app Rails.application end test 'GET /api/statuses/public_timeline returns an empty array of statuses' do get '/api/statuses/public_timeline' assert last_response.ok? assert_equal [], JSON.parse(last_response.body) end test 'GET /api/statuses/:id returns a status by id' do status = Status.create! get "/api/statuses/#{status.id}" assert_equal status.to_json, last_response.body end end ``` ### Stubbing Helpers Because helpers are mixed in based on the context when an endpoint is defined, it can be difficult to stub or mock them for testing. The `Grape::Endpoint.before_each` method can help by allowing you to define behavior on the endpoint that will run before every request. ```ruby describe 'an endpoint that needs helpers stubbed' do before do Grape::Endpoint.before_each do |endpoint| allow(endpoint).to receive(:helper_name).and_return('desired_value') end end after do Grape::Endpoint.before_each nil end it 'stubs the helper' do # ... end end ``` ## Reloading API Changes in Development ### Reloading in Rack Applications Use [grape-reload](https://github.com/AlexYankee/grape-reload). ### Reloading in Rails Applications Add API paths to `config/application.rb`. ```ruby # Auto-load API and its subdirectories config.paths.add File.join('app', 'api'), glob: File.join('**', '*.rb') config.autoload_paths += Dir[Rails.root.join('app', 'api', '*')] ``` Create `config/initializers/reload_api.rb`. ```ruby if Rails.env.development? ActiveSupport::Dependencies.explicitly_unloadable_constants << 'Twitter::API' api_files = Dir[Rails.root.join('app', 'api', '**', '*.rb')] api_reloader = ActiveSupport::FileUpdateChecker.new(api_files) do Rails.application.reload_routes! end ActionDispatch::Callbacks.to_prepare do api_reloader.execute_if_updated end end ``` See [StackOverflow #3282655](http://stackoverflow.com/questions/3282655/ruby-on-rails-3-reload-lib-directory-for-each-request/4368838#4368838) for more information. ## Performance Monitoring ### Active Support Instrumentation Grape has built-in support for [ActiveSupport::Notifications](http://api.rubyonrails.org/classes/ActiveSupport/Notifications.html) which provides simple hook points to instrument key parts of your application. The following are currently supported: #### endpoint_run.grape The main execution of an endpoint, includes filters and rendering. * *endpoint* - The endpoint instance #### endpoint_render.grape The execution of the main content block of the endpoint. * *endpoint* - The endpoint instance #### endpoint_run_filters.grape * *endpoint* - The endpoint instance * *filters* - The filters being executed * *type* - The type of filters (before, before_validation, after_validation, after) See the [ActiveSupport::Notifications documentation](http://api.rubyonrails.org/classes/ActiveSupport/Notifications.html) for information on how to subscribe to these events. ### Monitoring Products Grape integrates with following third-party tools: * **New Relic** - [built-in support](https://docs.newrelic.com/docs/agents/ruby-agent/frameworks/grape-instrumentation) from v3.10.0 of the official [newrelic_rpm](https://github.com/newrelic/rpm) gem, also [newrelic-grape](https://github.com/xinminlabs/newrelic-grape) gem * **Librato Metrics** - [grape-librato](https://github.com/seanmoon/grape-librato) gem * **[Skylight](https://www.skylight.io/)** - [skylight](https://github.com/skylightio/skylight-ruby) gem, [documentation](https://docs.skylight.io/grape/) ## Contributing to Grape Grape is work of hundreds of contributors. You're encouraged to submit pull requests, propose features and discuss issues. See [CONTRIBUTING](CONTRIBUTING.md). ## License MIT License. See LICENSE for details. ## Copyright Copyright (c) 2010-2015 Michael Bleigh, and Intridea, Inc. grape-0.16.2/Guardfile0000644000004100000410000000046612706307016014563 0ustar www-datawww-dataguard :rspec, all_on_start: true, cmd: 'bundle exec rspec' do watch(%r{^spec/.+_spec\.rb$}) watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" } watch('spec/spec_helper.rb') { 'spec' } end guard :rubocop do watch(/.+\.rb$/) watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) } end