rester 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ece68b86784e1eb6be50d4f6a18a5faba22277b0
-  data.tar.gz: 87fe10dabac3bd9bcc68027c8d1d32f16a90f543
+  metadata.gz: 781dcd45b4ea9347717fba375241286931b28444
+  data.tar.gz: 3319242e32b49c30316711918748809e736880fa
 SHA512:
-  metadata.gz: d0937a90725c306e6ca57c8673985c743df41fb63340377615d6ff53983fec13a24deea7e43ff6d861170ae6736863fa1c23aeec68e6cce265adf491758fd150
-  data.tar.gz: 8a660df186e630cd6473f2c0a3e073261a894008cf20053ae6bc89f79b38077eb3d64401f9e715eb16e75c0d238afea5f6d5d04c758728cc5cf3991b41591478
+  metadata.gz: 6d81ef7d638acb74488d729ccb22e41d749b6aa55afc00b8236d8ca84e1fd80e2798ca7e300a3c8a89e6af73a7bd9eacc913fa113d0b9f8331bd2031c271ab69
+  data.tar.gz: d2d00b634e8e052a15d0b819f813b417184722234253e5cc92cd8bd69b3f196a1d75d1fd5a26eb5e186c81930a3b134573f3a225cd2708ec0a3ede31fde44fde

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

@@ -1,6 +1,15 @@
 module Rester
   module Client::Adapters
     class Adapter
+
+      class << self
+        ##
+        # Returns whether or not the Adapter can connect to the service
+        def can_connect_to?(service)
+          raise NotImplementedError
+        end
+      end # Class Methods
+
       def initialize(*args)
         connect(*args) unless args.empty?
       end

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

@@ -5,6 +5,18 @@ module Rester
 
       attr_reader :connection
 
+      class << self
+        def can_connect_to?(service)
+          if service.is_a?(URI)
+            uri = service
+          elsif service.is_a?(String) && URI::regexp.match(service)
+            uri = URI(service)
+          end
+
+          !!uri && ['http', 'https'].include?(uri.scheme)
+        end
+      end # Class Methods
+
       def connect(*args)
         nil.tap { @connection = Connection.new(*args) }
       end

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

@@ -7,11 +7,15 @@ module Rester
     # An adapter for "connecting" to a service internally, without needing to
     # interface over a HTTP connection.
     class LocalAdapter < Adapter
-      attr_reader :version
       attr_reader :service
 
+      class << self
+        def can_connect_to?(service)
+          service.is_a?(Class) && service < Service
+        end
+      end # Class Methods
+
       def connect(service, opts={})
-        @version = opts[:version] || 1
         nil.tap { @service = service }
       end
 
@@ -43,7 +47,7 @@ module Rester
 
         response = service.call(
           'REQUEST_METHOD' => verb.to_s.upcase,
-          'PATH_INFO'      => Utils.join_paths("/v#{version}", path),
+          'PATH_INFO'      => path,
           'CONTENT_TYPE'   => 'application/x-www-form-urlencoded',
           'QUERY_STRING'   => query,
           'rack.input'     => StringIO.new(body)

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

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'json'
+require 'pathname'
+
+module Rester
+  module Client::Adapters
+    ##
+    # An adapter to be used to stub the responses needed from specified service
+    # requests via a yaml file. This will be used in spec tests to perform
+    # "contractual testing"
+    class StubAdapter < Adapter
+      attr_reader :stub
+
+      class << self
+        def can_connect_to?(service)
+          service.is_a?(String) && Pathname(service).file?
+        end
+      end # Class Methods
+
+      def connect(stub_filepath, opts={})
+        @stub = YAML.load_file(stub_filepath)
+      end
+
+      def connected?
+        !!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)
+      end
+
+      def context
+        @_context
+      end
+
+      def context=(context)
+        @_context = context
+      end
+
+      def with_context(context, &block)
+        self.context = context
+        yield block
+        self.context = nil
+      end
+
+      private
+
+      def _request(verb, path, params)
+        _validate_request(verb, path, params)
+
+        # At this point, the 'request' is valid by matching a corresponding
+        # request in the stub yaml file. Grab the response from the file and
+        # reset the context
+        response = stub[path][verb][context]['response']
+        context = nil
+        [response['code'], response['body'].to_json]
+      end
+
+      def _validate_request(verb, path, params)
+        fail Errors::StubError, "#{path} not found" unless stub[path]
+        fail Errors::StubError, "#{verb} #{path} not found" unless stub[path][verb]
+
+        unless (action = stub[path][verb][context])
+          fail Errors::StubError,
+            "#{verb} #{path} with context '#{context}' not found"
+        end
+
+        # Verify body, if there is one
+        if (request = action['request'])
+          unless Utils.symbolize_keys(request) == params
+            fail Errors::StubError,
+              "#{verb} #{path} with context '#{context}' params don't match stub"
+          end
+        end
+      end
+    end # StubAdapter
+  end # Client::Adapters
+end # Rester

data/lib/rester/client/adapters.rb

@@ -4,6 +4,14 @@ module Rester
       autoload(:Adapter,      'rester/client/adapters/adapter')
       autoload(:HttpAdapter,  'rester/client/adapters/http_adapter')
       autoload(:LocalAdapter, 'rester/client/adapters/local_adapter')
+      autoload(:StubAdapter,  'rester/client/adapters/stub_adapter')
+
+      class << self
+        def list
+          constants.map { |c| const_get(c) }
+            .select { |c| c.is_a?(Class) && c < Adapter }
+        end
+      end
     end
   end
 end

data/lib/rester/client/resource.rb

@@ -25,16 +25,11 @@ module Rester
 
       def method_missing(meth, *args, &block)
         meth = meth.to_s
-
-        unless args.length == 1
-          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
-        end
-
         arg = args.first
 
         case arg
-        when Hash
-          _handle_search_or_create(meth, arg)
+        when Hash, NilClass
+          _handle_search_or_create(meth, arg || {})
         when String, Symbol
           Resource.new(client, _path(meth, arg))
         else
@@ -54,6 +49,6 @@ module Rester
         verb, name = Utils.extract_method_verb(name)
         _request(verb, name, params)
       end
-    end # Object
+    end # Resource
   end # Client
 end # Rester

data/lib/rester/client/response.rb

@@ -0,0 +1,28 @@
+module Rester
+  class Client
+    class Response < Hash
+      def initialize(status, hash={})
+        @_status = status
+        merge!(hash)
+        _deep_freeze
+      end
+
+      def successful?
+        @_status && @_status.between?(200, 299)
+      end
+
+      private
+
+      def _deep_freeze(value=self)
+        value.freeze
+
+        case value
+        when Hash
+          value.values.each { |v| _deep_freeze(v) }
+        when Array
+          value.each { |v| _deep_freeze(v) }
+        end
+      end
+    end # Response
+  end # Client
+end # Rester

data/lib/rester/client.rb

@@ -5,17 +5,14 @@ module Rester
   class Client
     autoload(:Adapters, 'rester/client/adapters')
     autoload(:Resource, 'rester/client/resource')
+    autoload(:Response, 'rester/client/response')
 
     attr_reader :adapter
+    attr_reader :version
 
-    def initialize(*args)
-      case args.first
-      when Adapters::Adapter
-        self.adapter = args.first
-      else
-        self.adapter = Adapters::HttpAdapter.new(*args)
-      end
-
+    def initialize(adapter, params={})
+      self.adapter = adapter
+      @version = params[:version] || 1
       @_resource = Resource.new(self)
     end
 
@@ -24,13 +21,21 @@ module Rester
     end
 
     def connected?
-      adapter.connected? && adapter.get('status').first == 200
+      adapter.connected? && adapter.get('/ping').first == 200
     end
 
     def request(verb, path, params={}, &block)
+      path = _path_with_version(path)
+
       _process_response(path, *adapter.request(verb, path, params, &block))
     end
 
+    ##
+    # This is only implemented by the StubAdapter.
+    def with_context(*args, &block)
+      adapter.with_context(*args, &block)
+    end
+
     protected
 
     def adapter=(adapter)
@@ -45,16 +50,27 @@ module Rester
       @_resource.send(:method_missing, meth, *args, &block)
     end
 
+    def _path_with_version(path)
+      Utils.join_paths("/v#{version}", path)
+    end
+
     def _process_response(path, status, body)
-      if status.between?(200, 299)
-        _parse_json(body)
-      elsif status == 400
-        raise Errors::RequestError, _parse_json(body)[:message]
-      elsif status == 404
-        raise Errors::NotFoundError, "/#{path}"
-      else
-        raise Errors::ServerError, _parse_json(body)[:message]
+      response = Response.new(status, _parse_json(body))
+
+      unless [200, 201, 400].include?(status)
+        case status
+        when 401
+          fail Errors::AuthenticationError
+        when 403
+          fail Errors::ForbiddenError
+        when 404
+          fail Errors::NotFoundError, path
+        else
+          fail Errors::ServerError, response[:message]
+        end
       end
+
+      response
     end
 
     def _parse_json(data)

data/lib/rester/errors.rb

@@ -14,6 +14,10 @@ module Rester
     class MethodError < Error; end
     class MethodDefinitionError < Error; end
 
+    #############
+    # Stub Errors
+    class StubError < Error; end
+
     #############
     # Http Errors
     class HttpError < Error; end

data/lib/rester/middleware/error_handling.rb

@@ -23,11 +23,13 @@ module Rester
       def _error_to_response(error)
         code = _error_to_http_code(error)
 
-        unless code == 404
-          body_h = { message: error.message }
+        unless [401, 403, 404].include?(code)
+          body_h = {
+            message: error.message,
+            error: _error_name(error)
+          }
 
           if code == 500
-            body_h[:error] = error.class.name
             body_h[:backtrace] = error.backtrace
           end
         end
@@ -52,6 +54,10 @@ module Rester
           500
         end
       end
+
+      def _error_name(exception)
+        Utils.underscore(exception.class.name.split('::').last.sub('Error', ''))
+      end
     end # ErrorHandling
   end # Middleware
 end # Rester

data/lib/rester/middleware/{status_check.rb → ping.rb}

@@ -2,14 +2,14 @@ module Rester
   module Middleware
     ##
     # Provides a basic status check. Used by the Client#connected? method.
-    class StatusCheck < Base
+    class Ping < Base
       def call(env)
-        if %r{\A/v[\d+]/status\z}.match(env['REQUEST_PATH'])
+        if %r{\A/ping\z}.match(env['REQUEST_PATH'])
           [200, {}, []]
         else
           super
         end
       end
-    end # StatusCheck
+    end # Ping
   end # Middleware
 end # Rester

data/lib/rester/middleware.rb

@@ -2,6 +2,6 @@ module Rester
   module Middleware
     autoload(:Base,          'rester/middleware/base')
     autoload(:ErrorHandling, 'rester/middleware/error_handling')
-    autoload(:StatusCheck,   'rester/middleware/status_check')
+    autoload(:Ping,          'rester/middleware/ping')
   end
 end

data/lib/rester/rspec.rb

@@ -0,0 +1,152 @@
+require 'json'
+
+RSpec.configure do |config|
+  config.before :all, rester: // do |ex|
+    # Load the stub file
+    @rester_stub_filepath = ex.class.metadata[:rester]
+    @rester_stub = YAML.load_file(@rester_stub_filepath)
+
+    # Hook up the LocalAdapter with the Service being tested
+    unless (klass = ex.class.described_class) < Rester::Service
+      raise "invalid service to test"
+    end
+    @rester_adapter = Rester::Client::Adapters::LocalAdapter.new(klass, {})
+
+    _validate_test_coverage(ex)
+  end
+
+  config.before :each, rester: // do |ex|
+    # Gather the request args from the spec descriptions
+    #
+    # For example:
+    #
+    # describe '/v1/tests' do
+    #   context 'GET' do
+    #     context 'With some context' do
+    #     end
+    #   end
+    # end
+    #
+    # would produce:
+    #
+    # request_args = ['With some context', 'GET', '/v1/tests']
+    #
+    request_args = ex.example_group.parent_groups.map { |a|
+      a.description unless a.metadata[:description] == a.described_class.to_s
+    }.compact
+
+    context = request_args[0]
+    verb    = request_args[1]
+    path    = request_args[2]
+
+    begin
+      params   = @rester_stub[path][verb][context]['request']
+      response = @rester_stub[path][verb][context]['response']
+    rescue NoMethodError
+      fail Rester::Errors::StubError,
+        "Could not find path: #{path.inspect} verb: #{verb.inspect} context: #{context.inspect} in #{@rester_stub_filepath}"
+    end
+
+    ex.example_group.let(:subject) {
+      @rester_adapter.request(verb.downcase.to_sym, path, params)
+    }
+
+    ex.example_group.let(:stub_response) {
+      [response['code'], response['body'].to_json]
+    }
+  end
+
+  config.after :each, rester: // do |ex|
+    expect(subject).to eq stub_response
+  end
+
+  ##
+  # Check to see if each stub example has a corresponding test written for it
+  def _validate_test_coverage(ex)
+    rester_service_tests = _rester_service_tests(ex)
+    missing_tests = _missing_stub_tests(rester_service_tests)
+
+    # Loop through each missing stub test and create a corresponding RSpect test
+    # to display the missing tests as a failure to the user
+    missing_tests.each { |missing_path, missing_verbs|
+      path_group = _find_or_create_child(ex.class, missing_path)
+
+      missing_verbs.each { |missing_verb, missing_contexts|
+        verb_group = _find_or_create_child(path_group, missing_verb)
+
+        missing_contexts.each { |missing_context, _|
+          context_group = _find_or_create_child(verb_group, missing_context)
+          context_group.it { is_expected.to eq stub_response }
+        }
+      }
+    }
+  end
+
+  def _rester_service_tests(parent_example_group)
+    service_tests = {}
+    parent_example_group.class.children.each { |path_group|
+      path = path_group.description
+      service_tests[path] ||= {}
+
+      path_group.children.each { |verb_group|
+        verb = verb_group.description
+        service_tests[path][verb] ||= {}
+
+        verb_group.children.each { |context_group|
+          context =  context_group.description
+          service_tests[path][verb][context] = context_group.examples.count > 0
+        }
+      }
+    }
+
+    service_tests
+  end
+
+  ##
+  # Takes a hash produced by _rester_service_tests.
+  # Returns a hash of only the missing stub tests:
+  #
+  # {
+  #   "/v1/tests/abc123/mounted_objects" => {
+  #     "POST" => {
+  #       "With some context" => false
+  #     }
+  #   },
+  #   "/v1/stuff" => {
+  #     "GET" => {
+  #       "Doing that" => false
+  #     }
+  #   }
+  # }
+  def _missing_stub_tests(tests)
+    @rester_stub.reject { |k, _|
+      ['version', 'consumer', 'producer'].include?(k)
+    }.map { |path, verbs|
+      [
+        path,
+        verbs.map { |verb, contexts|
+          [
+            verb,
+            contexts.map { |context, _|
+              [
+                context,
+                !!(tests[path] && tests[path][verb] && tests[path][verb][context])
+              ]
+            }.to_h.reject { |_, v| v }
+          ]
+        }.to_h.reject { |_, v| v.empty? }
+      ]
+    }.to_h.reject { |_, v| v.empty? }
+  end
+
+  def _find_child_with_description(group, description)
+    group.children.find { |child_group|
+      child_group.description == description
+    }
+  end
+
+  def _find_or_create_child(group, description)
+    child = _find_child_with_description(group, description)
+    child || group.describe(description)
+  end
+end

data/lib/rester/service/{object/validator.rb → resource/params.rb}

@@ -1,17 +1,20 @@
 module Rester
-  class Service::Object
-    class Validator
+  class Service::Resource
+    class Params
       BASIC_TYPES = [String, Symbol, Float, Integer].freeze
 
       attr_reader :options
 
-      def initialize(opts={})
+      def initialize(opts={}, &block)
         @options = opts.dup.freeze
         @_required_fields = []
+        @_defaults = {}
         @_all_fields = []
 
         # Default "validator" is to just treat the param as a string.
         @_validators = Hash.new([String, {}])
+
+        instance_eval(&block) if block_given?
       end
 
       ##
@@ -24,17 +27,16 @@ module Rester
       def freeze
         @_validators.freeze
         @_required_fields.freeze
+        @_defaults.freeze
         @_all_fields.freeze
-      end
-
-      def required_params
-        @_required_fields.dup
+        super
       end
 
       def validate(params)
         param_keys = params.keys.map(&:to_sym)
+        default_keys = @_defaults.keys
 
-        unless (missing = @_required_fields - param_keys).empty?
+        unless (missing = @_required_fields - param_keys - default_keys).empty?
           _error!("missing params: #{missing.join(', ')}")
         end
 
@@ -42,30 +44,26 @@ module Rester
           _error!("unexpected params: #{unexpected.join(', ')}")
         end
 
-        params.map do |key, value|
+        validated_params = params.map do |key, value|
           [key.to_sym, validate!(key.to_sym, value)]
         end.to_h
+
+        @_defaults.merge(validated_params)
       end
 
       def validate!(key, value)
-        klass, opts = @_validators[key]
+        klass = @_validators[key].first
 
         _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
+          _validate_obj(key, obj)
         end
       end
 
+      def use(params)
+        _merge_params(params)
+        nil
+      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
@@ -87,6 +85,24 @@ module Rester
         _add_validator(name, :boolean, opts)
       end
 
+      protected
+
+      def required_params
+        @_required_fields.dup
+      end
+
+      def defaults
+        @_defaults.dup
+      end
+
+      def all_fields
+        @_all_fields.dup
+      end
+
+      def validators
+        @_validators.dup
+      end
+
       private
 
       def method_missing(meth, *args)
@@ -96,6 +112,8 @@ module Rester
           name = args.shift
           opts = args.shift || {}
           _add_validator(name, self.class.const_get(meth), opts)
+        else
+          super
         end
       end
 
@@ -103,12 +121,26 @@ module Rester
         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)
+        default = opts.delete(:default)
+
         @_all_fields << name.to_sym
         @_validators[name.to_sym] = [klass, opts]
+
+        if default
+          _validate_default(name.to_sym, default)
+          @_defaults[name.to_sym] = default
+        end
+
         nil
       end
 
+      def _validate_default(key, default)
+        error = catch(:error) { _validate_obj(key.to_sym, default) }
+        raise error if error
+      end
+
       def _parse_with_class(klass, value)
         return nil if value == 'null'
 
@@ -127,6 +159,39 @@ 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
+
+        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
+
+        nil
+      end
+
+      def _validate_type(key, obj, type)
+        case type
+        when :boolean
+          unless obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+            _error!("#{key} should be Boolean but got #{obj.class}")
+          end
+        else
+          unless obj.is_a?(type)
+            _error!("#{key} should be #{type} but got #{obj.class}")
+          end
+        end
+      end
+
       def _validate_within(key, obj, value)
         unless value.include?(obj)
           _error!("#{key} not within #{value.inspect}")
@@ -146,6 +211,13 @@ module Rester
       def _error!(message)
         Errors.throw_error!(Errors::ValidationError, message)
       end
+
+      def _merge_params(params)
+        @_validators       = @_validators.merge!(params.validators)
+        @_defaults         = @_defaults.merge!(params.defaults)
+        @_required_fields |= params.required_params
+        @_all_fields      |= params.all_fields
+      end
     end
   end
 end

data/lib/rester/service/resource.rb

@@ -0,0 +1,127 @@
+require 'rack'
+require 'active_support/inflector'
+
+module Rester
+  class Service
+    class Resource
+      autoload(:Params, 'rester/service/resource/params')
+
+      REQUEST_METHOD_TO_IDENTIFIED_METHOD = {
+        'GET'    => :get,
+        'PUT'    => :update,
+        'DELETE' => :delete
+      }.freeze
+
+      REQUEST_METHOD_TO_UNIDENTIFIED_METHOD = {
+        'GET'    => :search,
+        'POST'   => :create
+      }.freeze
+
+      RESOURCE_METHODS = [:search, :create, :get, :update, :delete].freeze
+
+      ########################################################################
+      # DSL
+      ########################################################################
+      class << self
+        ##
+        # Specify the name of your identifier (Default: 'id')
+        def id(name)
+          @id_name = name.to_sym
+        end
+
+        ##
+        # Mount another Service Resource
+        def mount(klass)
+          raise "Only other Service Resources can be mounted." unless klass < Resource
+          start = self.name.split('::')[0..-2].join('::').length + 2
+          mounts[klass.name[start..-1].pluralize.underscore] = klass
+        end
+
+        def params(opts={}, &block)
+          @_next_params = Params.new(opts, &block)
+        end
+      end # DSL
+
+      ########################################################################
+      # Class Methods
+      ########################################################################
+      class << self
+        def id_name
+          @id_name ||= :id
+        end
+
+        def id_param
+          "#{self.name.split('::').last.underscore}_#{id_name}"
+        end
+
+        def mounts
+          (@__mounts ||= {})
+        end
+
+        def method_params
+          @_method_params ||= {}
+        end
+
+        def method_added(method_name)
+          if RESOURCE_METHODS.include?(method_name.to_sym)
+            method_params[method_name.to_sym] = (@_next_params || Params.new).freeze
+          end
+          @_next_params = nil
+        end
+      end # Class Methods
+
+      def id_param
+        self.class.id_param
+      end
+
+      ##
+      # Given an HTTP request method, calls the appropriate calls the
+      # appropriate instance method. `id_provided` specifies whether on not the
+      # ID for the object is included in the params hash. This will be used when
+      # determining which instance method to call. For example, if the request
+      # method is GET: the ID being specified will call the `get` method and if
+      # it's not specified then it will call the `search` method.
+      def process(request_method, id_provided, params={})
+        meth = (id_provided ? REQUEST_METHOD_TO_IDENTIFIED_METHOD
+          : REQUEST_METHOD_TO_UNIDENTIFIED_METHOD)[request_method]
+
+        _process(meth, params).to_h
+      end
+
+      def mounts
+        self.class.mounts
+      end
+
+      def method_params_for(method_name)
+        self.class.method_params[method_name.to_sym]
+      end
+
+      def error!(message=nil)
+        Errors.throw_error!(Errors::RequestError, message)
+      end
+
+      private
+
+      ##
+      # Calls the specified method, passing the params if the method accepts
+      # an argument. Allows for the arity of the method to be 0, 1 or -1.
+      def _process(meth, params)
+        if meth && respond_to?(meth)
+          params = method_params_for(meth).validate(params)
+          meth = method(meth)
+
+          case meth.arity.abs
+          when 1
+            meth.call(params)
+          when 0
+            meth.call
+          else
+            fail MethodDefinitionError, "#{meth} must take 0 or 1 argument"
+          end
+        else
+          fail Errors::NotFoundError, meth
+        end
+      end
+    end # Resource
+  end # Service
+end # Rester

data/lib/rester/service.rb

@@ -5,7 +5,7 @@ require 'active_support/inflector'
 module Rester
   class Service
     autoload(:Request, 'rester/service/request')
-    autoload(:Object,  'rester/service/object')
+    autoload(:Resource,  'rester/service/resource')
 
     ##
     # The base set of middleware to use for every service.
@@ -13,7 +13,7 @@ module Rester
     BASE_MIDDLEWARE = [
       Rack::Head,
       Middleware::ErrorHandling,
-      Middleware::StatusCheck
+      Middleware::Ping
     ].freeze
 
     ########################################################################
@@ -68,15 +68,15 @@ module Rester
         const_get(version.to_s.upcase)
       end
 
-      def objects(version_module)
-        (@__objects ||= {})[version_module] ||= _load_objects(version_module)
+      def resources(version_module)
+        (@__resources ||= {})[version_module] ||= _load_resources(version_module)
       end
 
-      def _load_objects(version_module)
+      def _load_resources(version_module)
         version_module.constants.map { |c|
           version_module.const_get(c)
         }.select { |c|
-          c.is_a?(Class) && c < Service::Object
+          c.is_a?(Class) && c < Service::Resource
         }
       end
     end # Class methods
@@ -119,7 +119,7 @@ module Rester
     end
 
     ##
-    # Validates the request, calls the appropriate Service::Object method and
+    # Validates the request, calls the appropriate Service::Resource method and
     # returns a valid Rack response.
     def _process_request(request)
       _error!(Errors::NotFoundError) unless request.valid?
@@ -138,36 +138,35 @@ module Rester
     end
 
     ##
-    # Calls the appropriate method on the appropriate Service::Object for the
+    # Calls the appropriate method on the appropriate Service::Resource for the
     # request.
     def _call_method(request)
       params = request.params
       retval = nil
 
       name, id, *object_chain = request.object_chain
-      obj = _load_object(request, name)
+      obj = _load_resource(request, name)
 
       loop {
-        obj = obj.new(id) if id
+        params.merge!(obj.id_param => id) if id
 
         if object_chain.empty?
-          retval = obj.process(request.request_method, params)
+          retval = obj.process(request.request_method, !!id, params)
           break
         end
 
-        params.merge!(obj.id_param => obj.id)
         name, id, *object_chain = object_chain
-        obj = obj.mounts[name] or raise Errors::NotFoundError
+        obj = obj.mounts[name].new or fail Errors::NotFoundError
       }
 
       retval
     end
 
     ##
-    # Loads the appropriate Service::Object for the request. This will return
+    # Loads the appropriate Service::Resource for the request. This will return
     # the class, not an instance.
-    def _load_object(request, name)
-      _version_module(request).const_get(name.camelcase.singularize)
+    def _load_resource(request, name)
+      _version_module(request).const_get(name.camelcase.singularize).new
     rescue NameError
       _error!(Errors::NotFoundError)
     end
@@ -179,11 +178,9 @@ module Rester
     end
 
     ##
-    # Prepares the retval from a Service::Object method to be returned to the
+    # Prepares the retval from a Service::Resource method to be returned to the
     # client (i.e., validates it and dumps it as JSON).
     def _prepare_response(retval)
-      retval ||= {}
-
       unless retval.is_a?(Hash)
         _error!(Errors::ServerError, "Invalid response: #{retval.inspect}")
       end

data/lib/rester/utils.rb

@@ -49,6 +49,10 @@ module Rester
       def classify(str)
         str.to_s.split("_").map(&:capitalize).join
       end
+
+      def underscore(str)
+        str.scan(/[A-Z][a-z]*/).map(&:downcase).join('_')
+      end
     end # Class methods
   end # Utils
 end # Rester

data/lib/rester/version.rb

@@ -1,3 +1,3 @@
 module Rester
-  VERSION = '0.2.4'
+  VERSION = '0.3.0'
 end

data/lib/rester.rb

@@ -16,12 +16,11 @@ module Rester
       ].each { |rake_file| load rake_file }
     end
 
-    def connect(*args)
-      if (service = args.first).is_a?(Class) && service < Service
-        Client.new(Client::Adapters::LocalAdapter.new(*args))
-      else
-        Client.new(*args)
-      end
+    def connect(service, params={})
+      klass = Client::Adapters.list.find { |a| a.can_connect_to?(service) }
+      fail "unable to connect to #{service.inspect}" unless klass
+      adapter = klass.new(service)
+      Client.new(adapter, params)
     end
   end # Class Methods
 end # Rester

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rester
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2015-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -37,14 +37,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.13
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.13
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -130,17 +130,20 @@ files:
 - 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/adapters/stub_adapter.rb
 - lib/rester/client/resource.rb
+- lib/rester/client/response.rb
 - lib/rester/errors.rb
 - lib/rester/middleware.rb
 - lib/rester/middleware/base.rb
 - lib/rester/middleware/error_handling.rb
-- lib/rester/middleware/status_check.rb
+- lib/rester/middleware/ping.rb
 - lib/rester/railtie.rb
+- lib/rester/rspec.rb
 - lib/rester/service.rb
-- lib/rester/service/object.rb
-- lib/rester/service/object/validator.rb
 - lib/rester/service/request.rb
+- lib/rester/service/resource.rb
+- lib/rester/service/resource/params.rb
 - lib/rester/utils.rb
 - lib/rester/version.rb
 homepage: http://github.com/payout/rester
@@ -163,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A framework for creating simple RESTful interfaces between services.

data/lib/rester/service/object.rb

@@ -1,115 +0,0 @@
-require 'rack'
-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,
-        'DELETE' => :delete
-      }.freeze
-
-      REQUEST_METHOD_TO_CLASS_METHOD = {
-        'GET'    => :search,
-        'POST'   => :create
-      }.freeze
-
-      ########################################################################
-      # DSL
-      ########################################################################
-      class << self
-        ##
-        # Specify the name of your identifier (Default: 'id')
-        def id(name)
-          (@id_name = name.to_sym).tap { |name|
-            # Create the accessor method for the ID.
-            define_method(name) { @id } unless name == :id
-          }
-        end
-
-        ##
-        # Mount another Service Object
-        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].pluralize.underscore] = klass
-        end
-
-        def params(opts={}, &block)
-          (@_validator = Validator.new(opts)).instance_eval(&block)
-          @_validator.freeze
-        end
-      end # DSL
-
-      ########################################################################
-      # Class Methods
-      ########################################################################
-      class << self
-        def id_name
-          @id_name ||= :id
-        end
-
-        def id_param
-          "#{self.name.split('::').last.underscore}_#{id_name}"
-        end
-
-        def mounts
-          (@__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 meth && obj.respond_to?(meth)
-            params = validator.validate(params)
-            meth = obj.method(meth)
-
-            case meth.arity.abs
-            when 1
-              meth.call(params)
-            when 0
-              meth.call
-            else
-              raise MethodDefinitionError, "#{meth} must take 0 or 1 argument"
-            end
-          else
-            raise Errors::NotFoundError, meth
-          end
-        end
-
-        def process(request_method, params={})
-          meth = REQUEST_METHOD_TO_CLASS_METHOD[request_method]
-          process!(self, meth, params)
-        end
-      end # Class Methods
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id
-      end
-
-      def id_param
-        self.class.id_param
-      end
-
-      def process(request_method, params={})
-        meth = REQUEST_METHOD_TO_INSTANCE_METHOD[request_method]
-        self.class.process!(self, meth, params)
-      end
-
-      def mounts
-        self.class.mounts
-      end
-    end # Object
-  end # Service
-end # Rester