rester 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6fa57da0afc2d1f97912d9b52df6016e56fa1db
-  data.tar.gz: 25570c5f460cb04b857003e6956e4b28d7f00968
+  metadata.gz: e0666455190175ce3fb1d58396d5504c036a3bd0
+  data.tar.gz: e06f3d2e16a01ef7c2c5161749136d68a95b9fda
 SHA512:
-  metadata.gz: 3a7ac9757007d8e2bae0d4e31420dd9bc2c418c8bddd000d9e0b258d0161d029282e29963fdf7bcb27eba1340e97231c31af8a752336aaaa3b7d72a4db50c280
-  data.tar.gz: 207559692ae6d064e1bcd3ec44938e7853197d88a894365ae4220dbdfcfde03b9ad254dca8bdfa2cbb2f58038baa133eb9208edf4cce44efa91df0857ccb631e
+  metadata.gz: 77529a26c51aa18efbe08814151905556863f41cc79bd45e3804ce1951a436df2786dc053bf445a7c5ad92968cd1fb3a3e170c875052e4dde141c9d864da1dad
+  data.tar.gz: 7f66c1970e7f6c98c462f682df91a79eb5c1687c746d52321b0b1188cb05879064bf5e526ab2a775ffb440fcfc1fcf8456500b04de418a7567843c570a7900fa

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

@@ -28,7 +28,7 @@ module Rester
       def request(verb, path, params={}, &block)
         params ||= {}
         _validate_verb(verb)
-        _validate_params(params)
+        params = _validate_params(params)
         public_send("#{verb}!", path.to_s, params)
       end
 
@@ -62,48 +62,54 @@ module Rester
         delete: true
       }.freeze
 
-      VALID_ARG_TYPES = {
-        String  => true,
-        Symbol  => true,
-        Fixnum  => true,
-        Integer => true,
-        Float   => true
-      }.freeze
-
-      VALID_PARAM_KEY_TYPES = {
-        String   => true,
-        Symbol   => 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
 
-      VALID_PARAM_VALUE_TYPES = {
-        String   => true,
-        Symbol   => true,
-        Fixnum   => true,
-        Integer  => true,
-        Float    => true,
-        DateTime => true
-      }.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_args(args)
-        args.each { |arg|
-          VALID_ARG_TYPES[arg.class] or
-            raise ArgumentError, "Invalid argument type: #{arg.inspect}"
-        }
-      end
-
       def _validate_params(params)
-        params.each { |key, value|
-          VALID_PARAM_KEY_TYPES[key.class] or
-            raise ArgumentError, "Invalid param key type: #{key.inspect}"
-
-          VALID_PARAM_VALUE_TYPES[value.class] or
-            raise ArgumentError, "Invalid param value type: #{value.inspect}"
-        }
+        params.map { |key, value|
+          [
+            PARAM_KEY_TRANSFORMERS[key.class].call(key),
+            PARAM_VALUE_TRANSFORMERS[value.class].call(value)
+          ]
+        }.to_h
       end
     end # Adapter
   end # Client::Adapters

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

@@ -0,0 +1,50 @@
+require 'stringio'
+
+module Rester
+  module Client::Adapters
+    ##
+    # An adapter for "connecting" to a service internally, without needing to
+    # interface over a HTTP connection.
+    class LocalAdapter < Adapter
+      attr_reader :service
+
+      def connect(service)
+        nil.tap { @service = service }
+      end
+
+      def connected?
+        !!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)
+      end
+
+      private
+
+      def _request(verb, path, opts={})
+        body = URI.encode_www_form(opts[:data] || {})
+        query = URI.encode_www_form(opts[:query] || {})
+
+        service.call(
+          'REQUEST_METHOD' => verb.to_s.upcase,
+          'PATH_INFO'      => path,
+          'QUERY_STRING'   => query,
+          'rack.input'     => StringIO.new(body)
+        ).tap { |r| r.delete_at(1) }
+      end
+    end # LocalAdapter
+  end # Client::Adapters
+end # Rester

data/lib/rester/client/adapters.rb

@@ -1,8 +1,9 @@
 module Rester
   class Client
     module Adapters
-      autoload(:Adapter,     'rester/client/adapters/adapter')
-      autoload(:HttpAdapter, 'rester/client/adapters/http_adapter')
+      autoload(:Adapter,      'rester/client/adapters/adapter')
+      autoload(:HttpAdapter,  'rester/client/adapters/http_adapter')
+      autoload(:LocalAdapter, 'rester/client/adapters/local_adapter')
     end
   end
 end

data/lib/rester/client.rb

@@ -51,7 +51,7 @@ module Rester
       elsif status == 400
         raise Errors::RequestError, _parse_json(body)[:message]
       elsif status == 404
-        raise Errors::NotFoundError, _parse_json(body)[:message]
+        raise Errors::NotFoundError, "/#{path}"
       else
         raise Errors::ServerError, _parse_json(body)[:message]
       end

data/lib/rester/errors.rb

@@ -14,6 +14,8 @@ module Rester
     class MethodError < Error; end
     class MethodDefinitionError < Error; end
 
+    class ValidationError < Error; end
+
     #############
     # Http Errors
     class HttpError < Error; end

data/lib/rester/middleware/error_handling.rb

@@ -21,11 +21,19 @@ module Rester
       private
 
       def _error_to_response(error)
-        Rack::Response.new(
-          [JSON.dump(message: error.message)],
-          _error_to_http_code(error),
-          { "Content-Type" => "application/json"}
-        )
+        code = _error_to_http_code(error)
+
+        unless code == 404
+          body_h = { message: error.message }
+
+          if code == 500
+            body_h[:error] = error.class.name
+            body_h[:backtrace] = error.backtrace
+          end
+        end
+
+        body = body_h ? [JSON.dump(body_h)] : []
+        Rack::Response.new(body, code, { "Content-Type" => "application/json"})
       end
 
       def _error_to_http_code(error)

data/lib/rester/service/object/validator.rb

@@ -0,0 +1,151 @@
+module Rester
+  class Service::Object
+    class Validator
+      BASIC_TYPES = [String, Symbol, Float, Integer].freeze
+
+      attr_reader :options
+
+      def initialize(opts={})
+        @options = opts.dup.freeze
+        @_required_fields = []
+        @_all_fields = []
+
+        # Default "validator" is to just treat the param as a string.
+        @_validators = Hash.new([String, {}])
+      end
+
+      ##
+      # Whether or not validation will be done strictly (i.e., only specified
+      # params will be allowed).
+      def strict?
+        !!options[:strict]
+      end
+
+      def freeze
+        @_validators.freeze
+        @_required_fields.freeze
+        @_all_fields.freeze
+      end
+
+      def required_params
+        @_required_fields.dup
+      end
+
+      def validate(params)
+        param_keys = params.keys.map(&:to_sym)
+
+        unless (missing = @_required_fields - param_keys).empty?
+          _error!("missing params: #{missing.join(', ')}")
+        end
+
+        if strict? && !(unexpected = param_keys - @_all_fields).empty?
+          _error!("unexpected params: #{unexpected.join(', ')}")
+        end
+
+        params.map do |key, value|
+          [key.to_sym, validate!(key.to_sym, value)]
+        end.to_h
+      end
+
+      def validate!(key, value)
+        klass, opts = @_validators[key]
+
+        _parse_with_class(klass, value).tap do |obj|
+          if obj.nil? && @_required_fields.include?(key)
+            _error!("#{key} cannot be null")
+          end
+
+          opts.each do |opt, value|
+            case opt
+            when :within
+              _validate_within(key, obj, value)
+            else
+              _validate_method(key, obj, opt, value) unless obj.nil?
+            end
+          end
+        end
+      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
+      # same as doing 1234.to_s.
+      #
+      # Since methods already exist globally for these types, we need to override
+      # 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={}|
+          _add_validator(name, type, opts)
+        }
+      end
+
+      ##
+      # Need to have special handling for Boolean since Ruby doesn't have a
+      # Boolean type, instead it has TrueClass and FalseClass...
+      def Boolean(name, opts={})
+        _add_validator(name, :boolean, opts)
+      end
+
+      private
+
+      def method_missing(meth, *args)
+        meth_str = meth.to_s
+
+        if meth.to_s.match(/\A[A-Z][A-Za-z]+\z/)
+          name = args.shift
+          opts = args.shift || {}
+          _add_validator(name, self.class.const_get(meth), opts)
+        end
+      end
+
+      def _add_validator(name, klass, opts)
+        fail 'must specify param name' unless name
+        fail 'validation options must be a Hash' unless opts.is_a?(Hash)
+        opts = opts.dup
+        @_required_fields << name.to_sym if opts.delete(:required)
+        @_all_fields << name.to_sym
+        @_validators[name.to_sym] = [klass, opts]
+        nil
+      end
+
+      def _parse_with_class(klass, value)
+        return nil if value == 'null'
+
+        if klass == String
+          value
+        elsif klass == Integer
+          value.to_i
+        elsif klass == Float
+          value.to_f
+        elsif klass == Symbol
+          value.to_sym
+        elsif klass == :boolean
+          value.downcase == 'true' ? true : false
+        else
+          klass.parse(value)
+        end
+      end
+
+      def _validate_within(key, obj, value)
+        unless value.include?(obj)
+          _error!("#{key} not within #{value.inspect}")
+        end
+      end
+
+      def _validate_method(key, obj, opt, value)
+        unless (meth = obj.respond_to?(opt) && obj.method(opt))
+          _error!("#{key} does not respond to #{opt.inspect}")
+        end
+
+        unless meth.call(*value)
+          _error!("#{key} failed #{opt}(#{[value].flatten.join(',')}) validation")
+        end
+      end
+
+      def _error!(message)
+        Errors.throw_error!(Errors::ValidationError, message)
+      end
+    end
+  end
+end

data/lib/rester/service/object.rb

@@ -4,6 +4,8 @@ require 'active_support/inflector'
 module Rester
   class Service
     class Object
+      autoload(:Validator, 'rester/service/object/validator')
+
       REQUEST_METHOD_TO_INSTANCE_METHOD = {
         'GET'    => :get,
         'PUT'    => :update,
@@ -33,7 +35,12 @@ module Rester
         def mount(klass)
           raise "Only other Service Objects can be mounted." unless klass < Object
           start = self.name.split('::')[0..-2].join('::').length + 2
-          mounts[klass.name[start..-1].underscore] = klass
+          mounts[klass.name[start..-1].pluralize.underscore] = klass
+        end
+
+        def params(opts={}, &block)
+          (@_validator = Validator.new(opts)).instance_eval(&block)
+          @_validator.freeze
         end
       end # DSL
 
@@ -53,12 +60,17 @@ module Rester
           (@__mounts ||= {})
         end
 
+        def validator
+          @_validator ||= Validator.new
+        end
+
         ##
         # Helper method called at the class and instance level that calls the
         # specified method on the passed object with the params. Allows for
         # the arity of the method to be 0, 1 or -1.
         def process!(obj, meth, params)
-          if obj.respond_to?(meth)
+          if meth && obj.respond_to?(meth)
+            params = validator.validate(params)
             meth = obj.method(meth)
 
             case meth.arity.abs

data/lib/rester/service.rb

@@ -133,7 +133,7 @@ module Rester
     # If the version is not found, it throws a NotFoundError (HTTP 404).
     def _validate_version(request)
       unless self.class.versions.include?(request.version)
-        _error!(Errors::NotFoundError)
+        _error!(Errors::NotFoundError, request.version)
       end
     end
 

data/lib/rester/version.rb

@@ -1,3 +1,3 @@
 module Rester
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/rester.rb

@@ -17,7 +17,11 @@ module Rester
     end
 
     def connect(*args)
-      Client.new(*args)
+      if (service = args.first).is_a?(Class) && service < Service
+        Client.new(Client::Adapters::LocalAdapter.new(service))
+      else
+        Client.new(*args)
+      end
     end
   end # Class Methods
 end # Rester

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rester
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-04 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -101,6 +101,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A framework for creating simple RESTful interfaces between services.
 email:
 - robert@payout.com
@@ -115,6 +129,7 @@ files:
 - lib/rester/client/adapters/adapter.rb
 - lib/rester/client/adapters/http_adapter.rb
 - lib/rester/client/adapters/http_adapter/connection.rb
+- lib/rester/client/adapters/local_adapter.rb
 - lib/rester/client/resource.rb
 - lib/rester/errors.rb
 - lib/rester/middleware.rb
@@ -124,6 +139,7 @@ files:
 - lib/rester/railtie.rb
 - lib/rester/service.rb
 - lib/rester/service/object.rb
+- lib/rester/service/object/validator.rb
 - lib/rester/service/request.rb
 - lib/rester/utils.rb
 - lib/rester/version.rb
@@ -147,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A framework for creating simple RESTful interfaces between services.