scorpio 0.6.4 → 0.7.0

data/lib/scorpio/resource_base.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module Scorpio
-  class RequestSchemaFailure < Error
-  end
-
   class ResourceBase
     class << self
       # ResourceBase.inheritable_accessor_defaults is a hash of accessor names (Symbol) mapped 
@@ -22,23 +19,20 @@ module Scorpio
         define_singleton_method(accessor, &default_getter)
         inheritable_accessor_defaults[accessor] = singleton_class.instance_method(accessor)
         # field setter method. redefines the getter, replacing the method with one that returns the
-        # setter's argument (that being inherited to the scope of the define_method(accessor) block
+        # setter's argument `value`
         define_singleton_method(:"#{accessor}=") do |value|
-          # the setter operates on the singleton class of the receiver (self)
-          singleton_class.instance_exec(value, self) do |value_, klass|
             # remove a previous getter. NameError is raised if a getter is not defined on this class;
             # this may be ignored.
             begin
-              remove_method(accessor)
+              singleton_class.send(:remove_method, accessor)
             rescue NameError
             end
             # getter method
-            define_method(accessor) { value_ }
+            define_singleton_method(accessor) { value }
             # invoke on_set callback defined on the class
             if on_set
-              klass.instance_exec(&on_set)
+              instance_exec(&on_set)
             end
-          end
         end
       end
     end
@@ -50,7 +44,7 @@ module Scorpio
         end
         update_dynamic_methods
       else
-        self.represented_schemas = JSI::SchemaSet.ensure_schema_set(represented_schemas)
+        self.represented_schemas = JSI::SchemaSet.new(represented_schemas)
       end
     end)
     define_inheritable_accessor(:models_by_schema, default_value: {}.freeze)
@@ -72,8 +66,8 @@ module Scorpio
       if openapi_document && openapi_document.v2?
         raise(ArgumentError, "servers are not supported for OpenAPI V2")
       end
-      unless server.is_a?(Scorpio::OpenAPI::V3::Server)
-        raise(TypeError, "server must be an #{Scorpio::OpenAPI::V3::Server.inspect}. received: #{server.pretty_inspect.chomp}")
+      unless server.is_a?(OpenAPI::Server)
+        raise(TypeError, -"server must be an #{OpenAPI::Server}. received: #{server.pretty_inspect.chomp}")
       end
     })
 
@@ -91,7 +85,7 @@ module Scorpio
       end
 
       def openapi_document=(openapi_document)
-        openapi_document = OpenAPI::Document.from_instance(openapi_document)
+        openapi_document = Scorpio.new_document(openapi_document)
 
         begin
           singleton_class.instance_exec { remove_method(:openapi_document) }
@@ -106,9 +100,9 @@ module Scorpio
         define_singleton_method(:openapi_document_class) { openapi_document_class }
         define_singleton_method(:openapi_document=) do |_|
           if self == openapi_document_class
-            raise(ArgumentError, "openapi_document may only be set once on #{inspect}")
+            raise(ArgumentError, -"openapi_document may only be set once on #{inspect}")
           else
-            raise(ArgumentError, "openapi_document may not be overridden on subclass #{inspect} after it was set on #{openapi_document_class.inspect}")
+            raise(ArgumentError, -"openapi_document may not be overridden on subclass #{inspect} after it was set on #{openapi_document_class.inspect}")
           end
         end
         # TODO blame validate openapi_document
@@ -121,7 +115,7 @@ module Scorpio
 
       def tag_name=(tag_name)
         unless tag_name.respond_to?(:to_str)
-          raise(TypeError, "tag_name must be a string; got: #{tag_name.inspect}")
+          raise(TypeError, -"tag_name must be a string; got: #{tag_name.inspect}")
         end
         tag_name = tag_name.to_str
 
@@ -132,7 +126,7 @@ module Scorpio
         define_singleton_method(:tag_name) { tag_name }
         define_singleton_method(:tag_name=) do |tag_name|
           unless tag_name == self.tag_name
-            raise(ArgumentError, "tag_name may not be overridden (to #{tag_name.inspect}). it is been set to #{self.tag_name.inspect}")
+            raise(ArgumentError, -"tag_name may not be overridden (to #{tag_name.inspect}). it is been set to #{self.tag_name.inspect}")
           end
         end
         update_dynamic_methods
@@ -163,13 +157,16 @@ module Scorpio
       end
 
       def operation_for_resource_class?(operation)
-        return true if tag_name && operation.tags.respond_to?(:to_ary) && operation.tags.include?(tag_name)
+        return true if tag_name && operation.tagged?(tag_name)
 
         request_response_schemas = operation.request_schemas | operation.response_schemas
         # TODO/FIX nil instance is wrong. works for $ref and allOf, not for others.
         # use all inplace applicators, not conditional on instance
-        all_request_response_schemas = request_response_schemas.each_inplace_applicator_schema(nil)
-        return true if all_request_response_schemas.any? { |s| represented_schemas.include?(s) }
+        request_response_schemas.each do |s|
+          s.each_inplace_applicator_schema(nil) do |ias|
+            return true if represented_schemas.include?(ias)
+          end
+        end
 
         return false
       end
@@ -181,11 +178,14 @@ module Scorpio
         #
         # TODO/FIX nil instance is wrong. works for $ref and allOf, not for others.
         # use all inplace applicators, not conditional on instance
-        all_request_schemas = operation.request_schemas.each_inplace_applicator_schema(nil)
-        return true if all_request_schemas.any? { |s| represented_schemas.include?(s) }
+        operation.request_schemas.each do |s|
+          s.each_inplace_applicator_schema(nil) do |ias|
+            return true if represented_schemas.include?(ias)
+          end
+        end
 
         # the below only apply if the operation has this resource's tag
-        return false unless tag_name && operation.tags.respond_to?(:to_ary) && operation.tags.include?(tag_name)
+        return false unless tag_name && operation.tagged?(tag_name)
 
         # define an instance method if path or query params can be filled in from
         # property names described by represented_schemas
@@ -223,8 +223,7 @@ module Scorpio
         # if the operationId is just "addPet"
         # then the operation's method name on Pet will be "addPet".
         tag_name_match = tag_name &&
-          operation.tags.respond_to?(:to_ary) && # TODO maybe operation.tags.valid?
-          operation.tags.include?(tag_name) &&
+          operation.tagged?(tag_name) &&
           operation.operationId &&
           operation.operationId.match(/\A#{Regexp.escape(tag_name)}[\.\/\:](\w+)\z/)
 
@@ -236,9 +235,7 @@ module Scorpio
       end
 
       def update_class_and_instance_api_methods
-        openapi_document.paths.each do |path, path_item|
-          path_item.each do |http_method, operation|
-            next unless operation.is_a?(Scorpio::OpenAPI::Operation)
+        openapi_document.operations.each do |operation|
             method_name = api_method_name_by_operation(operation)
             if method_name
               # class method
@@ -255,11 +252,15 @@ module Scorpio
                 end
               end
             end
-          end
         end
       end
 
       def call_operation(operation, call_params: nil, model_attributes: nil)
+        result, _ur = call_operation_ur(operation, call_params: call_params, model_attributes: model_attributes)
+        result
+      end
+
+      def call_operation_ur(operation, call_params: nil, model_attributes: nil)
         call_params = JSI::Util.stringify_symbol_keys(call_params) if call_params.respond_to?(:to_hash)
         model_attributes = JSI::Util.stringify_symbol_keys(model_attributes || {})
 
@@ -311,18 +312,19 @@ module Scorpio
           other_params = call_params
         end
 
-        if operation.request_schema
+        request_schema = request.request_schema
+        if request_schema
           request_body_for_schema = -> (o) do
             if o.is_a?(JSI::Base)
               # TODO check indicated schemas
-              if o.jsi_schemas.include?(operation.request_schema)
+              if o.jsi_schemas.include?(request_schema)
                 jsi = o
               else
                 # TODO maybe better way than reinstantiating another jsi as request_schema
-                jsi = operation.request_schema.new_jsi(o.jsi_node_content)
+                jsi = request_schema.new_jsi(o.jsi_node_content)
               end
             else
-              jsi = operation.request_schema.new_jsi(o)
+              jsi = request_schema.new_jsi(o)
             end
             jsi.jsi_select_descendents_leaf_first do |node|
               # we want to specifically reject only nodes described (only) by a false schema.
@@ -342,12 +344,19 @@ module Scorpio
           end
         else
           if other_params
-            if Request.method_with_body?(request.http_method)
+            if request.http_method_with_body?
               request.body_object = other_params
             else
               if other_params.respond_to?(:to_hash)
-                # TODO pay more attention to 'parameters' api method attribute
-                request.query_params = other_params
+                other_params.to_hash.each_pair do |name, value|
+                  param = request.param_for(name)
+                  if param
+                    request.set_param_from(param['in'], param['name'], value)
+                  else
+                    # set any params not described by operation params in the query
+                    request.set_param_from('query', name, value)
+                  end
+                end
               else
                 raise
               end
@@ -364,7 +373,7 @@ module Scorpio
           'source' => {'operationId' => operation.operationId, 'call_params' => call_params, 'url' => ur.request.uri.to_s},
           'ur' => ur,
         }
-        response_object_to_instances(ur.response.body_object, initialize_options)
+        [response_object_to_instances(ur.response.body_object(mutable: true), initialize_options), ur]
       end
 
       def response_object_to_instances(object, initialize_options = {})
@@ -375,7 +384,7 @@ module Scorpio
           elsif models.size == 1
             model = models.first
           else
-            raise(Scorpio::OpenAPI::Error, "multiple models indicated by response JSI. models: #{models.inspect}; object: #{object.pretty_inspect.chomp}")
+            raise(Scorpio::OpenAPI::Error, -"multiple models indicated by response JSI. models: #{models.inspect}; object: #{object.pretty_inspect.chomp}")
           end
 
           if model && object.respond_to?(:to_hash)
@@ -422,12 +431,12 @@ module Scorpio
       end
 
       def inspect
-        "\#<#{self.class.inspect} #{contained_object.inspect}>"
+        -"\#<#{self.class.inspect} #{contained_object.inspect}>"
       end
 
       def pretty_print(q)
         q.instance_exec(self) do |obj|
-          text "\#<#{obj.class.inspect}"
+          text(-"\#<#{obj.class.inspect}")
           group_sub {
             nest(2) {
               breakable ' '
@@ -474,15 +483,14 @@ module Scorpio
     end
 
     def call_operation(operation, call_params: nil)
-      response = self.class.call_operation(operation, call_params: call_params, model_attributes: self.attributes)
+      response, ur = self.class.call_operation_ur(operation, call_params: call_params, model_attributes: self.attributes)
 
       # if we're making a POST or PUT and the request schema is this resource, we'll assume that
       # the request is persisting this resource
-      request_resource_is_self = operation.request_schema && self.class.represented_schemas.include?(operation.request_schema)
-      if @options['ur'].is_a?(Scorpio::Ur)
-        response_schema = @options['ur'].response.response_schema
-      end
-      response_resource_is_self = response_schema && self.class.represented_schemas.include?(response_schema)
+      request_body_object = ur.scorpio_request.body_object
+      request_resource_is_self = request_body_object.is_a?(JSI::Base) &&
+        request_body_object.jsi_schemas.any? { |s| self.class.represented_schemas.include?(s) }
+      response_resource_is_self = response.is_a?(self.class)
       if request_resource_is_self && %w(put post).include?(operation.http_method.to_s.downcase)
         @persisted = true
 
@@ -557,7 +565,7 @@ module Scorpio
           ks = k.is_a?(String) ? k :
             k.is_a?(Symbol) ? k.to_s :
             k.respond_to?(:to_str) && (kstr = k.to_str).is_a?(String) ? kstr :
-            raise(TypeError, "JSON object (Hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
+            raise(TypeError, -"JSON object (Hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
           hash[ks] = JSI::Util.as_json(self[k], **options)
         end
         hash
@@ -608,7 +616,7 @@ module Scorpio
         if schema_names.empty?
           [Container.to_s]
         else
-          ["#{Container} (#{schema_names.join(', ')})"]
+          [-"#{Container} (#{schema_names.join(', ')})"]
         end
       end
     end

data/lib/scorpio/response.rb

@@ -3,6 +3,8 @@
 module Scorpio
   Response = Scorpio::Ur.properties['response']
 
+  # Scorpio::Response is a JSI schema module describing the same instances as [::Ur::Response](https://rubydoc.info/gems/ur/Ur/Response).
+  # It relies on methods of that module.
   module Response
     # the schema for this response according to its OpenAPI doc
     # @return [::JSI::Schema]
@@ -10,32 +12,48 @@ module Scorpio
       ur.scorpio_request.operation.response_schema(status: status, media_type: media_type)
     end
 
-    # the body (String) is parsed according to the response media type, if supported (only JSON is
-    # currently supported), and instantiated as a JSI instance of {#response_schema} if that is defined.
-    def body_object
+    # media types for which Scorpio has implemented parsing {Response#body_object} from `Response#body`
+    SUPPORTED_MEDIA_TYPES = %w(
+      application/json
+    ).map(&:freeze).freeze
+
+    # the body (String) is parsed according to the response media type, if
+    # supported (see {Response::SUPPORTED_MEDIA_TYPES}), and instantiated
+    # as a JSI instance of {#response_schema} if that is defined.
+    #
+    # @param mutable [Boolean] instantiate the response body object as mutable?
+    def body_object(mutable: false)
+      k = [:body_object, mutable]
+      @memos.fetch(k) { @memos[k] = compute_body_object(mutable: mutable) }
+    end
+
+    private def compute_body_object(mutable: false)
       if json?
         if body.empty?
           # an empty body isn't valid json, of course, but we'll just return nil for it.
           body_object = nil
         else
           begin
-            body_object = ::JSON.parse(body)
+            body_object = JSON.parse(body, freeze: !mutable)
           #rescue ::JSON::ParserError
             # TODO
           end
         end
 
-        if response_schema && (body_object.respond_to?(:to_hash) || body_object.respond_to?(:to_ary))
-          body_object = response_schema.new_jsi(body_object, mutable: true)
-        end
+      # NOTE: the supported media types above should correspond to Response::SUPPORTED_MEDIA_TYPES
 
-        body_object
       elsif content_type && content_type.type_text? && content_type.subtype?('plain')
-        body
+        body_object = body
       else
         # we will return the body if we do not have a supported parsing. for now.
-        body
+        body_object = body
       end
+
+      if response_schema && (body_object.respond_to?(:to_hash) || body_object.respond_to?(:to_ary))
+        body_object = response_schema.new_jsi(body_object, mutable: mutable)
+      end
+
+      body_object
     end
   end
 end

data/lib/scorpio/ur.rb

@@ -12,9 +12,13 @@ module Scorpio
     }
   })
 
-  -> { Scorpio::Response }.() # invoke autoload
+  Scorpio::Response.itself # invoke autoload. this is Scorpio::Ur.properties['response']
 
   module Ur
+    Request = Ur.properties["request"]
+
+    # The Scorpio::Request from which this Ur was run
+    # @return [Scorpio::Request]
     attr_accessor :scorpio_request
 
     # raises a subclass of Scorpio::HTTPError if the response has an error status.
@@ -24,7 +28,7 @@ module Scorpio
     # raises a generic HTTPError otherwise.
     #
     # @raise [Scorpio::HTTPError]
-    # @return [void]
+    # @return [nil]
     def raise_on_http_error
       error_class = Scorpio.error_classes_by_status[response.status]
       error_class ||= if (400..499).include?(response.status)
@@ -35,7 +39,7 @@ module Scorpio
         HTTPError
       end
       if error_class
-        message = "Error calling operation #{scorpio_request.operation.human_id}:\n" + response.body
+        message = -"Error calling operation #{scorpio_request.operation.human_id}:\n#{response.body}"
         raise(error_class.new(message).tap do |e|
           e.ur = self
           e.response_object = response.body_object

data/lib/scorpio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Scorpio
-  VERSION = "0.6.4".freeze
+  VERSION = "0.7.0".freeze
 end

data/lib/scorpio.rb

@@ -9,6 +9,7 @@ require "pathname"
 require "pp"
 
 module Scorpio
+  # @private
   def self.root
     @root ||= Pathname.new(__FILE__).dirname.parent.expand_path
   end
@@ -17,6 +18,7 @@ end
 module Scorpio
   # generally put in code paths that are not expected to be valid control flow paths.
   # rather a NotImplementedCorrectlyError. but that's too long.
+  # @private
   class Bug < NotImplementedError
   end
 
@@ -31,12 +33,9 @@ module Scorpio
     # @param status [Integer] if specified, sets the HTTP status the class represents
     # @return [Integer] the HTTP status the class represents
     def self.status(status = nil)
-      if status
-        @status = status
-        Scorpio.error_classes_by_status[status] = self
-      else
-        @status
-      end
+      return @status if !status
+      Scorpio.error_classes_by_status[status] = self
+      @status = status
     end
     attr_accessor :ur, :response_object
   end
@@ -107,4 +106,11 @@ module Scorpio
   autoload :ResourceBase, 'scorpio/resource_base'
   autoload :Request, 'scorpio/request'
   autoload :Response, 'scorpio/response'
+
+  class << self
+    # (see OpenAPI::Document.new_document)
+    def new_document(instance, **new_param)
+      OpenAPI::Document.new_document(instance, **new_param)
+    end
+  end
 end

data/pages/Request_Configuration.md

@@ -0,0 +1,69 @@
+# Request Configuration
+
+Scorpio aims to offer flexibility in how applications can configure requests. Requests are initiated from an Operation object (e.g. {Scorpio::OpenAPI::Operation#run}), utilizing the Operation and the OpenAPI document that contains it for configuration. Many configurable attributes can be set with varying granularity, on the document (applying to all requests from all operations, unless overridden), on the operation (applying to all requests from that operation), or on the request itself.
+
+Configurable attributes are defined on several modules: for a request, {Scorpio::Request::Configurables}; for an operation, {Scorpio::OpenAPI::Operation::Configurables}; and for a document {Scorpio::OpenAPI::Document::Configurables} and {Scorpio::OpenAPI::Operation::V3Methods::Configurables} or {Scorpio::OpenAPI::Operation::V2Methods::Configurables}.
+
+{Scorpio::Request#initialize} and methods that instantiate a request (such as {Scorpio::OpenAPI::Operation#run}) take a keyword hash of configuration, which may include attributes defined on the Configurables module, or parameters defined by the operation (except where parameter names conflict with configurable attributes, or are ambiguous).
+
+So for example, given this OpenAPI document:
+
+```yaml
+openapi: 3.1.0
+info: {title: example, version: '1'}
+servers:
+- url: "https://{subdomain}.example.com/v1"
+  variables:
+    subdomain:
+      default: api
+paths:
+  '/foos/{id}':
+    patch:
+      operationId: foos.patch
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+  '/bars/{id}':
+    patch:
+      operationId: bars.patch
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+        - name: id
+          in: query
+          schema:
+            type: string
+```
+
+then the following Ruby code demonstrates how configuration is inherited from document to operation to request and how parameters are applied.
+
+Note that `build_request` takes the same parameters as `run` or `run_ur` would; it is used since we are not hitting a real API.
+
+```ruby
+# instantiate OAD whose content is the same as the yaml above
+oad = Scorpio::OpenAPI::Document.from_instance({"openapi"=>"3.1.0", "info"=>{"title"=>"example", "version"=>"1"}, "servers"=>[{"url"=>"https://{subdomain}.example.com/v1", "variables"=>{"subdomain"=>{"default"=>"api"}}}], "paths"=>{"/foos/{id}"=>{"patch"=>{"operationId"=>"foos.patch", "parameters"=>[{"name"=>"id", "in"=>"path", "required"=>true, "schema"=>{"type"=>"string"}}]}}, "/bars/{id}"=>{"patch"=>{"operationId"=>"bars.patch", "parameters"=>[{"name"=>"id", "in"=>"path", "required"=>true, "schema"=>{"type"=>"string"}}, {"name"=>"id", "in"=>"query", "schema"=>{"type"=>"string"}}]}}}})
+
+# configure document level server subdomain
+oad.server_variables = {subdomain: 'east'}
+# configure operation level server subdomain
+oad.operations['bars.patch'].server_variables = {subdomain: 'north'}
+
+# uses document server_variables and sets id as request path param
+oad.operations['foos.patch'].build_request(id: 'C7').url
+ # https://east.example.com/v1/foos/C7
+
+# sets id as request path param and sets server_variables request config
+oad.operations['foos.patch'].build_request(id: 'C7', server_variables: {subdomain: 'west'}).url
+# https://west.example.com/v1/foos/C7
+
+# uses operation server_variables. since `id` is a param name in both path and query, `id` alone
+# cannot be used as configuration; it must be set on the appropriate params' configurations
+oad.operations['bars.patch'].build_request(path_params: {id: 'C7'}, query_params: {id: 'D7'}).url
+# https://north.example.com/v1/bars/C7?id=D7
+```

data/pages/Security.md

@@ -0,0 +1,50 @@
+# API Security
+
+Scorpio does not currently implement an interface for any particular API security mechanism, which an OpenAPI description might specify using an operation's Security Requirement and corresponding Security Scheme. Scorpio offers flexibility in how applications may authenticate using common mechanisms - for more general guidance see {file:Request_Configuration Request Configuration}.
+
+### Authorization header
+
+An authorization header can be set using the `authorization` configuration on an OpenAPI document, operation, or request:
+
+```ruby
+# applies to every request (unless overridden per operation or request)
+my_openapi_document.authorization = "Basic bm90RXRoYW46cDRzc3cwcmQ"
+
+# or, applying to every request from my_operation (unless overridden)
+my_operation.authorization = "Basic bm90RXRoYW46cDRzc3cwcmQ"
+
+# or, per request:
+my_operation.run(authorization: "Basic bm90RXRoYW46cDRzc3cwcmQ")
+```
+
+### Another header
+
+Any other request headers can be set similarly:
+
+```ruby
+# document
+my_openapi_document.request_headers = {"Api-Key" => "bm90RXRoYW46cDRzc3cwcmQ"}
+
+# operation
+my_operation.request_headers = {"Api-Key" => "bm90RXRoYW46cDRzc3cwcmQ"}
+
+# request (note: just `headers` not `request_headers` here)
+my_operation.run(headers: {"Api-Key" => "bm90RXRoYW46cDRzc3cwcmQ"})
+```
+
+### Faraday request middleware
+
+Faraday middleware can be used to set headers or other components of the request, by configuring `faraday_builder`. If authentication must be computed for each request (e.g. by including a signature of the request), configured Faraday middleware is invoked for each request. Faraday middleware libraries exist for common authentication mechanisms - see [awesome-faraday](https://github.com/lostisland/awesome-faraday).
+
+```ruby
+# document
+my_openapi_document.faraday_builder = proc do |faraday_connection|
+  faraday_connection.request(:authorization, :basic, 'notEthan', 'p4ssw0rd')
+end
+
+# operation
+my_operation.faraday_builder = proc { |c| c.request(:authorization, :basic, 'notEthan', 'p4ssw0rd') }
+
+# request
+my_operation.run(faraday_builder: proc { |c| c.request(:authorization, :basic, 'notEthan', 'p4ssw0rd') })
+```

data/scorpio.gemspec

@@ -6,10 +6,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ethan"]
   spec.email         = ["ethan@unth.net"]
 
-  spec.summary       = 'Scorpio REST client'
-  spec.description   = 'ORM style REST client'
+  spec.summary       = "Scorpio web API client"
+  spec.description   = "Scorpio offers a client interface to any web API described by an OpenAPI description, following ORM conventions for RESTful resources."
   spec.homepage      = "https://github.com/notEthan/scorpio"
-  spec.license       = "AGPL-3.0"
+  spec.license       = "AGPL-3.0-only"
 
   spec.files = [
     'LICENSE.md',
@@ -19,12 +19,13 @@ Gem::Specification.new do |spec|
     'scorpio.gemspec',
     *Dir['lib/**/*'],
     *Dir['documents/**/*'],
+    *Dir['pages/**/*'],
   ].reject { |f| File.lstat(f).ftype == 'directory' }
 
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "jsi", "~> 0.8.1"
+  spec.add_dependency("jsi", "~> 0.9")
   spec.add_dependency "ur", "~> 0.2.5"
-  spec.add_dependency "faraday", "< 3.0"
+  spec.add_dependency "faraday"
   spec.add_dependency "addressable", '~> 2.3'
 end