rester 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed31a2e9f930e5607d9905098c61fae665750d3a
-  data.tar.gz: a3cfb90ab6eb177fd2291d5bd6e5013014023f63
+  metadata.gz: e0d4b971390eaa9fe9c3aa6abdfb754f141bd8bb
+  data.tar.gz: 23c86151fc635c434a83249f85b0a66f66bf93ce
 SHA512:
-  metadata.gz: fb965a25b5f15759c4998897c831a4959d512d6b89225d8228879ed2e8185cb99397617417ee54b7c8e2b69444d5f8af1ca9ba8a903e7fd39b70d2ea407ccb58
-  data.tar.gz: a9fc47ffea8f0a68e66f8577e82e1733d06639c6ba7a8275121ddd92deee1b131ee42ca1192cb492e65b86fd0d7e3530c58abb8b2db190e330697011b333caa7
+  metadata.gz: 3782bdebc01e6c081ab57224f025b9c8abc0f5002b83f3cf120b67626232f42855910714885e0d0f49572eb011b8e3e537f175fa0aa13e4d0db3e5d7c9e9839c
+  data.tar.gz: 6fe88686d1afa14ee878b4868ee3e67e201ca4ede8dfdaf0a9c4ab4369b81812cf51542aad5cd6cbec05042c0e624547af3457aabc4d5bd030d0111092406792

data/lib/rester/client/adapters/adapter.rb

@@ -36,11 +36,22 @@ module Rester
         raise NotImplementedError
       end
 
-      def request(verb, path, params={})
-        params ||= {}
+      ##
+      # Sends an HTTP request to the service.
+      #
+      # `params` should be a hash if specified.
+      def request(verb, path, params = nil)
         _validate_verb(verb)
-        params = _validate_params(params)
-        public_send("#{verb}!", path.to_s, params)
+        request!(verb, path.to_s, Utils.encode_www_data(params))
+      end
+
+      ##
+      # Sends an HTTP request to the service.
+      #
+      # `encoded_data` should be URL encoded set of parameters
+      # (e.g., "key1=value1&key2=value2")
+      def request!(verb, path, encoded_data)
+        fail NotImplementedError
       end
 
       [:get, :post, :put, :delete].each do |verb|
@@ -49,13 +60,6 @@ module Rester
         define_method(verb) { |*args|
           request(verb, *args)
         }
-
-        ##
-        # Define implementation methods: get!, post!, put!, delete!
-        # These methods should be overridden by the specific adapter.
-        define_method("#{verb}!") { |*args|
-          raise NotImplementedError
-        }
       end
 
       protected
@@ -73,54 +77,9 @@ module Rester
         delete: true
       }.freeze
 
-      ##
-      # PARAM_KEY_TRANSFORMERS
-      #
-      # Defines how to transform a key value before being sent to the server.
-      # At the moment, this is a simple to_s conversion.
-      PARAM_KEY_TRANSFORMERS = Hash.new { |_, key|
-        proc { |value|
-          fail ArgumentError, "Invalid param key type: #{key.inspect}"
-        }
-      }.merge(
-        String   => :to_s.to_proc,
-        Symbol   => :to_s.to_proc
-      ).freeze
-
-      ##
-      # PARAM_VALUE_TRANSFORMERS
-      #
-      # Defines how values should be transformed before being sent to the
-      # server. Mostly, this is just a simple conversion to a string, but in
-      # the case of `nil` we want to convert it to 'null'.
-      PARAM_VALUE_TRANSFORMERS = Hash.new { |_, key|
-        proc { |value|
-          fail ArgumentError, "Invalid param value type: #{key.inspect}"
-        }
-      }.merge(
-        String     => :to_s.to_proc,
-        Symbol     => :to_s.to_proc,
-        Fixnum     => :to_s.to_proc,
-        Integer    => :to_s.to_proc,
-        Float      => :to_s.to_proc,
-        DateTime   => :to_s.to_proc,
-        TrueClass  => :to_s.to_proc,
-        FalseClass => :to_s.to_proc,
-        NilClass   => proc { 'null' }
-      ).freeze
-
       def _validate_verb(verb)
         VALID_VERBS[verb] or
-          raise ArgumentError, "Invalid verb: #{verb.inspect}"
-      end
-
-      def _validate_params(params)
-        params.map { |key, value|
-          [
-            PARAM_KEY_TRANSFORMERS[key.class].call(key),
-            PARAM_VALUE_TRANSFORMERS[value.class].call(value)
-          ]
-        }.to_h
+          fail ArgumentError, "Invalid verb: #{verb.inspect}"
       end
     end # Adapter
   end # Client::Adapters

data/lib/rester/client/adapters/http_adapter/connection.rb

@@ -18,44 +18,18 @@ module Rester
         @timeout = opts[:timeout]
       end
 
-      def get(path, params={})
+      def request(verb, path, params={})
         _request(
-          :get,
+          verb,
           _path(path, params[:query]),
-          _prepare_headers(params[:headers])
-        )
-      end
-
-      def delete(path, params={})
-        _request(
-          :delete,
-          _path(path, params[:query]),
-          _prepare_headers(params[:headers])
-        )
-      end
-
-      def put(path, params={})
-        _request(
-          :put,
-          _path(path),
-          _prepare_data_headers(params[:headers]),
-          _encode_data(params[:data])
-        )
-      end
-
-      def post(path, params={})
-        _request(
-          :post,
-          _path(path),
-          _prepare_data_headers(params[:headers]),
-          _encode_data(params[:data])
+          _headers(verb, params[:headers]),
+          params[:data]
         )
       end
 
       private
 
-      def _request(verb, path, headers={}, data='')
-        data = nil if [:get, :delete].include?(verb)
+      def _request(verb, path, headers, data)
         _http.public_send(verb, *[path, data, headers].compact)
       rescue Net::ReadTimeout, Net::OpenTimeout
         fail Errors::TimeoutError
@@ -64,12 +38,16 @@ module Rester
       def _path(path, query=nil)
         u = url.dup
         u.path = Utils.join_paths(u.path, path)
-        u.query = URI.encode_www_form(query) if query && !query.empty?
+        u.query = query if query
         u.request_uri
       end
 
-      def _encode_data(data)
-        URI.encode_www_form(data || {})
+      def _headers(verb, headers)
+        if [:post, :put].include?(verb)
+          _prepare_data_headers(headers)
+        else
+          _prepare_headers(headers)
+        end
       end
 
       def _prepare_data_headers(headers)

data/lib/rester/client/adapters/http_adapter.rb

@@ -25,24 +25,14 @@ module Rester
         !!connection
       end
 
-      def get!(path, params={})
+      def request!(verb, path, encoded_data)
         _require_connection
-        _prepare_response(connection.get(path, headers: headers, query: params))
-      end
 
-      def delete!(path, params={})
-        _require_connection
-        _prepare_response(connection.delete(path, headers: headers, query: params))
-      end
+        data_key = [:get, :delete].include?(verb) ? :query : :data
+        response = connection.request(verb, path,
+          headers: headers, data_key => encoded_data)
 
-      def put!(path, params={})
-        _require_connection
-        _prepare_response(connection.put(path, headers: headers, data: params))
-      end
-
-      def post!(path, params={})
-        _require_connection
-        _prepare_response(connection.post(path, headers: headers, data: params))
+        _prepare_response(response)
       end
 
       private

data/lib/rester/client/adapters/local_adapter.rb

@@ -12,7 +12,7 @@ module Rester
 
       class << self
         def can_connect_to?(service)
-          service.is_a?(Class) && service < Service
+          service.is_a?(Class) && !!(service < Service)
         end
       end # Class Methods
 
@@ -24,27 +24,16 @@ module Rester
         !!service
       end
 
-      def get!(path, params={})
-        _request(:get, path, headers: headers, query: params)
-      end
-
-      def delete!(path, params={})
-        _request(:delete, path, headers: headers, query: params)
-      end
-
-      def put!(path, params={})
-        _request(:put, path, headers: headers, data: params)
-      end
-
-      def post!(path, params={})
-        _request(:post, path, headers: headers, data: params)
+      def request!(verb, path, encoded_data)
+        data_key = [:get, :delete].include?(verb) ? :query : :data
+        _request(verb, path, headers: headers, data_key => encoded_data)
       end
 
       private
 
       def _request(verb, path, opts={})
-        body = URI.encode_www_form(opts[:data] || {})
-        query = URI.encode_www_form(opts[:query] || {})
+        body = opts[:data] || ''
+        query = opts[:query] || ''
 
         response = Timeout::timeout(timeout) do
           service.call(

data/lib/rester/client/adapters/stub_adapter.rb

@@ -30,20 +30,9 @@ module Rester
         !!stub
       end
 
-      def get!(path, params={})
-        _request('GET', path, params)
-      end
-
-      def post!(path, params={})
-        _request('POST', path, params)
-      end
-
-      def put!(path, params={})
-        _request('PUT', path, params)
-      end
-
-      def delete!(path, params={})
-        _request('DELETE', path, params)
+      def request!(verb, path, encoded_data)
+        params = Rack::Utils.parse_nested_query(encoded_data)
+        _request(verb.to_s.upcase, path, params)
       end
 
       def with_context(context)
@@ -60,8 +49,13 @@ module Rester
       end
 
       def _process_request(path, verb, params)
-        fail Errors::StubError, "#{path} not found" unless stub[path]
-        fail Errors::StubError, "#{verb} #{path} not found" unless stub[path][verb]
+        unless stub[path]
+          fail Errors::StubError, "#{path} not found"
+        end
+
+        unless stub[path][verb]
+          fail Errors::StubError, "#{verb} #{path} not found"
+        end
 
         context = @_context || _find_context_by_params(path, verb, params)
 
@@ -70,10 +64,13 @@ module Rester
             "#{verb} #{path} with context '#{context}' not found"
         end
 
-        # Verify body, if there is one
-        unless (request = spec['request']) == params
+        # Verify request params. Compile a list of mismatched params values and
+        # any incoming request param keys which aren't specified in the stub
+        unless (spec_params = spec['request']) == params
+          diff = _param_diff(params, spec_params)
           fail Errors::StubError,
-            "#{verb} #{path} with context '#{context}' params don't match stub. Expected: #{request} Got: #{params}"
+            "#{verb} #{path} with context '#{context}' params don't match "\
+            "stub: #{diff}"
         end
 
         # At this point, the 'request' is valid by matching a corresponding
@@ -81,6 +78,30 @@ module Rester
         stub[path][verb][context]
       end
 
+      ##
+      # Generate the diff string in the case when the request params of the
+      # service don't match the params specified in the stub file.
+      def _param_diff(params, spec_params)
+        params = params.dup
+        # Compile a list of mismatched params values
+        diff = spec_params.map { |k,v|
+          param_value = params.delete(k)
+          unless v == param_value
+            "#{k.inspect} should equal #{v.inspect} but got "\
+              "#{param_value.inspect}"
+          end
+        }.compact.join(', ')
+
+        unless params.empty?
+          # Add any param keys which aren't specified in the spec
+          diff << ', and ' unless diff.empty?
+          unexpected_str = params.keys.map(&:to_s).map(&:inspect).join(', ')
+          diff << "received unexpected key(s): #{unexpected_str}"
+        end
+
+        diff
+      end
+
       ##
       # Find the first request object with the same params as what's passed in.
       # Useful for testing without having to set the context.

data/lib/rester/service/resource/params.rb

@@ -2,7 +2,7 @@ module Rester
   class Service::Resource
     class Params
       DEFAULT_OPTS = { strict: true }.freeze
-      BASIC_TYPES = [String, Symbol, Float, Integer].freeze
+      BASIC_TYPES = [String, Symbol, Float, Integer, Array, Hash].freeze
 
       DEFAULT_TYPE_MATCHERS = {
         Integer  => /\A\d+\z/,
@@ -59,14 +59,8 @@ module Rester
       end
 
       def validate!(key, value)
-        _error!("expected string value for #{key}") unless value.is_a?(String)
-
         klass, opts = @_validators[key]
-        _validate_match(key, value, opts[:match]) if opts[:match]
-
-        _parse_with_class(klass, value).tap do |obj|
-          _validate_obj(key, obj)
-        end
+        _validate(key, value, klass, opts)
       end
 
       def use(params)
@@ -74,6 +68,10 @@ module Rester
         nil
       end
 
+      def required?(key)
+        @_required_fields.include?(key.to_sym)
+      end
+
       ##
       # The basic data types all have helper methods named after them in Kernel.
       # This allows you to do things like String(1234) to get '1234'. It's the
@@ -83,7 +81,13 @@ module Rester
       # them so we can capture their calls. If this weren't the case, then we'd
       # be catch them in `method_missing`.
       BASIC_TYPES.each do |type|
-        define_method(type.to_s) { |name, opts={}|
+        define_method(type.to_s) { |name, opts={}, &block|
+          if type == Hash || (type == Array && opts[:type] == Hash)
+            elem_type = (options = @options.merge(opts)).delete(:type)
+            opts = elem_type ? { type: elem_type } : {}
+            opts.merge!(use: self.class.new(options, &block))
+          end
+
           _add_validator(name, type, opts)
         }
       end
@@ -167,9 +171,49 @@ module Rester
         raise error if error
       end
 
-      def _parse_with_class(klass, value)
-        return nil if value == 'null'
+      ##
+      # Validates and parses a given value. `klass` is the intended type for the
+      # value (e.g., String, Integer, Array, etc.). `opts` contains the
+      # validation options.
+      def _validate(key, value, klass, opts)
+        case value
+        when String
+          _validate_str(key, value, klass, opts)
+        when Array
+          _validate_array(key, value, klass, opts)
+        when Hash
+          _validate_hash(key, value, klass, opts)
+        when NilClass
+          _validate_required(key, false)
+        else
+          _error!("unexpected value type for #{key}: #{value.class}")
+        end
+      end
+
+      def _validate_str(key, value, klass, opts)
+        fail unless value.is_a?(String) # assert
+
+        _validate_match(key, value, opts[:match]) if opts[:match]
+        _parse_with_class(klass, value).tap do |obj|
+          _validate_type(key, obj, klass) if obj
+          _validate_obj(key, obj, opts)
+        end
+      end
 
+      def _validate_array(key, value, klass, opts)
+        _error!("unexpected array for #{key}") unless klass == Array
+        type = (opts = opts.dup).delete(:type) || String
+
+        value.each_with_index
+          .map { |e, i| _validate("#{key}[#{i}]", e, type, opts) }
+      end
+
+      def _validate_hash(key, value, klass, opts)
+        _error!("unexpected hash for #{key}") unless klass == Hash
+        (validator = opts[:use]) && validator.validate(value)
+      end
+
+      def _parse_with_class(klass, value)
         if klass == String
           value
         elsif klass == Integer
@@ -185,13 +229,8 @@ module Rester
         end
       end
 
-      def _validate_obj(key, obj)
-        if obj.nil? && @_required_fields.include?(key)
-          _error!("#{key} cannot be null")
-        end
-
-        klass, opts = @_validators[key]
-        _validate_type(key, obj, klass) if obj
+      def _validate_obj(key, obj, opts)
+        fail if obj.nil? # Assert, at this point should be guaranteed
 
         opts.each do |opt, value|
           case opt
@@ -213,6 +252,20 @@ module Rester
         end
       end
 
+      def _validate_required(key, is_defined)
+        unless is_defined
+          _, key, index = /(\w+)(\[\d+\])?/.match(key).to_a
+
+          if required?(key)
+            if index
+              _error!("#{key} cannot contain null elements")
+            else
+              _error!("#{key} cannot be null")
+            end
+          end
+        end
+      end
+
       def _valid_type?(obj, type)
         case type
         when :boolean

data/lib/rester/utils/stub_file.rb

@@ -56,7 +56,7 @@ module Rester
         # Converts all the values in the request hash to strings, which mimics
         # how the data will be received on the service side.
         def _update_request(path, verb, context, spec)
-          spec['request'] = Utils.stringify_vals(spec['request'] || {})
+          spec['request'] = Utils.stringify(spec['request'] || {})
         end
 
         ##

data/lib/rester/utils.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'uri'
 
 module Rester
   module Utils
@@ -20,6 +21,38 @@ module Rester
         end
       end
 
+      ##
+      # Copied from Rack::Utils.build_nested_query (version 1.6.0)
+      #
+      # We want to be able to support Rack >= 1.5.2, but this method is broken
+      # in that version.
+      def encode_www_data(value, prefix = nil)
+        # Rack::Utils.build_nested_query(value)
+        case value
+        when Array
+          value.map { |v|
+            encode_www_data(v, "#{prefix}[]")
+          }.join("&")
+        when Hash
+          value.map { |k, v|
+            encode_www_data(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          }.reject(&:empty?).join('&')
+        when nil
+          prefix
+        else
+          raise ArgumentError, "value must be a Hash" if prefix.nil?
+          "#{prefix}=#{escape(value)}"
+        end
+      end
+
+      def decode_www_data(data)
+        Rack::Utils.parse_nested_query(data)
+      end
+
+      def escape(value)
+        URI.encode_www_form_component(value)
+      end
+
       def join_paths(*paths)
         paths.map(&:to_s).reject { |p| p.nil? || p.empty? }
           .join('/').gsub(/\/+/, '/')
@@ -50,17 +83,10 @@ module Rester
         hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
       end
 
-      def stringify_vals(hash={})
-        hash.each_with_object({}) { |(k,v), memo|
-          case v
-          when Hash
-            memo[k] = stringify_vals(v)
-          when NilClass
-            memo[k] = 'null'
-          else
-            memo[k] = v.to_s
-          end
-        }
+      ##
+      # Converts all keys and values to strings.
+      def stringify(hash={})
+        decode_www_data(encode_www_data(hash))
       end
 
       def classify(str)

data/lib/rester/version.rb

@@ -1,3 +1,3 @@
 module Rester
-  VERSION = '0.4.2'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rester
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-04 00:00:00.000000000 Z
+date: 2015-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack