rester 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 891fe3d740381cb54c48e89ad69fca06e1fc06d6
-  data.tar.gz: db402da2918dc425d879b3719fc41e976b1de4bf
+  metadata.gz: f6fa57da0afc2d1f97912d9b52df6016e56fa1db
+  data.tar.gz: 25570c5f460cb04b857003e6956e4b28d7f00968
 SHA512:
-  metadata.gz: 1a4992cf642165b17d1e77e854ac9fdaadef82ccc45337548d0a902048bb372dc9574713ff5109f5baba43e3f0c730b1c299c005932314d1ff5bc803ca6d087b
-  data.tar.gz: 4b9ef3355867f57f67632b24dffd84b9d39027d94544d8681058b27e01fe204418dc04b3a9b843ad48fdcf9b412460dda07707bdfbc74ed77bac057b38a347e2
+  metadata.gz: 3a7ac9757007d8e2bae0d4e31420dd9bc2c418c8bddd000d9e0b258d0161d029282e29963fdf7bcb27eba1340e97231c31af8a752336aaaa3b7d72a4db50c280
+  data.tar.gz: 207559692ae6d064e1bcd3ec44938e7853197d88a894365ae4220dbdfcfde03b9ad254dca8bdfa2cbb2f58038baa133eb9208edf4cce44efa91df0857ccb631e

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

@@ -25,32 +25,26 @@ module Rester
         raise NotImplementedError
       end
 
-      def request(verb, method, *args, &block)
+      def request(verb, path, params={}, &block)
+        params ||= {}
         _validate_verb(verb)
-        params = _validate_params(args.pop) if args.last.is_a?(Hash)
-        _validate_args(args)
-
-        public_send(
-          "#{verb}!",
-          "/#{method}/#{args.map(&:to_s).join('/')}",
-          params
-        )
+        _validate_params(params)
+        public_send("#{verb}!", path.to_s, params)
       end
 
-      def get(method, *args, &block)
-        request(:get, method, *args, &block)
-      end
-
-      def post(method, *args, &block)
-        request(:post, method, *args, &block)
-      end
-
-      def get!(path, params={})
-        raise NotImplementedError
-      end
+      [:get, :post, :put, :delete].each do |verb|
+        ##
+        # Define helper methods: get, post, put, delete
+        define_method(verb) { |*args, &block|
+          request(verb, *args, &block)
+        }
 
-      def post!(path, params={})
-        raise NotImplementedError
+        ##
+        # Define implementation methods: get!, post!, put!, delete!
+        # These methods should be overridden by the specific adapter.
+        define_method("#{verb}!") { |*args, &block|
+          raise NotImplementedError
+        }
       end
 
       protected
@@ -62,8 +56,10 @@ module Rester
       private
 
       VALID_VERBS = {
-        get: true,
-        post: true
+        get:    true,
+        post:   true,
+        put:    true,
+        delete: true
       }.freeze
 
       VALID_ARG_TYPES = {

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

@@ -5,7 +5,7 @@ require 'uri'
 module Rester
   module Client::Adapters
     class HttpAdapter::Connection
-      DEFAULT_POST_HEADERS = {
+      DEFAULT_DATA_HEADERS = {
         "Content-Type".freeze => "application/x-www-form-urlencoded".freeze
       }.freeze
 
@@ -23,9 +23,22 @@ module Rester
         )
       end
 
+      def delete(path, params={})
+        _http.delete(
+          _path(path, params[:query]),
+          _prepare_headers(params[:headers])
+        )
+      end
+
+      def put(path, params={})
+        encoded_data = _encode_data(params[:data])
+        headers = _prepare_data_headers(params[:headers])
+        _http.put(_path(path), encoded_data, headers)
+      end
+
       def post(path, params={})
-        headers = DEFAULT_POST_HEADERS.merge(_prepare_headers(params[:headers]))
-        encoded_data = URI.encode_www_form(params[:data] || {})
+        encoded_data = _encode_data(params[:data])
+        headers = _prepare_data_headers(params[:headers])
         _http.post(_path(path), encoded_data, headers)
       end
 
@@ -33,11 +46,19 @@ module Rester
 
       def _path(path, query=nil)
         u = url.dup
-        u.path += path
+        u.path = Utils.join_paths(u.path, path)
         u.query = URI.encode_www_form(query) if query && !query.empty?
         u.request_uri
       end
 
+      def _encode_data(data)
+        URI.encode_www_form(data || {})
+      end
+
+      def _prepare_data_headers(headers)
+        DEFAULT_DATA_HEADERS.merge(_prepare_headers(headers))
+      end
+
       def _http
         Net::HTTP.new(url.hostname, url.port).tap { |http|
           if (http.use_ssl=url.is_a?(URI::HTTPS))

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

@@ -14,10 +14,22 @@ module Rester
       end
 
       def get!(path, params={})
+        _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
+
+      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))
       end
 
@@ -26,6 +38,10 @@ module Rester
       def _prepare_response(response)
         [response.code.to_i, response.body]
       end
+
+      def _require_connection
+        raise "not connected" unless connected?
+      end
     end # HttpAdapter
   end # Client::Adapters
 end # Rester

data/lib/rester/client/resource.rb

@@ -0,0 +1,59 @@
+module Rester
+  class Client
+    class Resource
+      attr_reader :client
+      attr_reader :path
+
+      def initialize(client, path='')
+        @client = client
+        @path = path
+      end
+
+      def get(params={})
+        _request(:get, '', params)
+      end
+
+      def update(params={})
+        _request(:put, '', params)
+      end
+
+      def delete(params={})
+        _request(:delete, '', params)
+      end
+
+      private
+
+      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 String, Symbol
+          Resource.new(client, _path(meth, arg))
+        else
+          raise ArgumentError, "invalid argument type #{arg.inspect}"
+        end
+      end
+
+      def _request(verb, path, params={})
+        client.request(verb, _path(path), params)
+      end
+
+      def _path(*args)
+        Utils.join_paths(path, *args)
+      end
+
+      def _handle_search_or_create(name, params)
+        verb, name = Utils.extract_method_verb(name)
+        _request(verb, name, params)
+      end
+    end # Object
+  end # Client
+end # Rester

data/lib/rester/client.rb

@@ -1,8 +1,10 @@
 require 'json'
+require 'active_support/inflector'
 
 module Rester
   class Client
     autoload(:Adapters, 'rester/client/adapters')
+    autoload(:Resource, 'rester/client/resource')
 
     attr_reader :adapter
 
@@ -13,6 +15,8 @@ module Rester
       else
         self.adapter = Adapters::HttpAdapter.new(*args)
       end
+
+      @_resource = Resource.new(self)
     end
 
     def connect(*args)
@@ -20,7 +24,11 @@ module Rester
     end
 
     def connected?
-      adapter.connected? && adapter.get(:test_connection).first == 200
+      adapter.connected? && adapter.get('status').first == 200
+    end
+
+    def request(verb, path, params={}, &block)
+      _process_response(path, *adapter.request(verb, path, params, &block))
     end
 
     protected
@@ -34,17 +42,16 @@ module Rester
     ##
     # Submits the method to the adapter.
     def method_missing(meth, *args, &block)
-      verb, meth = Utils.extract_method_verb(meth)
-      _process_response(meth, *adapter.request(verb, meth, *args, &block))
+      @_resource.send(:method_missing, meth, *args, &block)
     end
 
-    def _process_response(meth, status, body)
+    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::InvalidMethodError, meth.to_s
+        raise Errors::NotFoundError, _parse_json(body)[:message]
       else
         raise Errors::ServerError, _parse_json(body)[:message]
       end

data/lib/rester/errors.rb

@@ -11,11 +11,8 @@ module Rester
     end # Class Methods
 
     class Error < StandardError; end
-
-    ##
-    # Packet errors
-    class PacketError < Error; end
-    class InvalidEncodingError < PacketError; end
+    class MethodError < Error; end
+    class MethodDefinitionError < Error; end
 
     #############
     # Http Errors
@@ -35,18 +32,8 @@ module Rester
 
     # 404 Not Found
     class NotFoundError < RequestError; end
-    class InvalidMethodError < NotFoundError; end
 
     # 500 ServerError
     class ServerError < RequestError; end
-
-    ##
-    # Server Errors
-
-    # General Errors
-    class InvalidValueError < Error; end
-
-    # Rester Errors
-    class ServiceNotDefinedError < Error; end
   end # Errors
 end # Rester

data/lib/rester/middleware/status_check.rb

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

data/lib/rester/middleware.rb

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

data/lib/rester/service/object.rb

@@ -0,0 +1,103 @@
+require 'rack'
+require 'active_support/inflector'
+
+module Rester
+  class Service
+    class Object
+      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].underscore] = klass
+        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
+
+        ##
+        # 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)
+            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

data/lib/rester/service/request.rb

@@ -0,0 +1,27 @@
+require 'rack'
+
+module Rester
+  class Service
+    class Request < Rack::Request
+      attr_reader :version
+      attr_reader :object_chain
+
+      def initialize(env)
+        super
+        _parse_path if valid?
+      end
+
+      def valid?
+        path.length < 256 && %r{\A/v\d+/(\w+/?)+\z}.match(path)
+      end
+
+      private
+
+      def _parse_path
+        _, version, *pieces = path.split(/\/+/)
+        @version = version.downcase.to_sym
+        @object_chain = pieces.map(&:freeze)
+      end
+    end # Request
+  end # Service
+end # Rester

data/lib/rester/service.rb

@@ -1,19 +1,41 @@
 require 'uri'
 require 'rack'
+require 'active_support/inflector'
 
 module Rester
   class Service
+    autoload(:Request, 'rester/service/request')
+    autoload(:Object,  'rester/service/object')
+
     ##
     # The base set of middleware to use for every service.
     # Middleware will be executed in the order specified.
     BASE_MIDDLEWARE = [
       Rack::Head,
-      Middleware::ErrorHandling
+      Middleware::ErrorHandling,
+      Middleware::StatusCheck
     ].freeze
 
-    # Used to signify an empty body
-    class EmptyResponse; end
+    ########################################################################
+    # DSL
+    ########################################################################
+    class << self
+      ###
+      # Middleware DSL
+      ###
 
+      def use(klass, *args)
+        _middleware << [klass, *args]
+      end
+
+      def _middleware
+        @__middleware ||= BASE_MIDDLEWARE.dup
+      end
+    end # DSL
+
+    ########################################################################
+    # Class Methods
+    ########################################################################
     class << self
       def instance
         @instance ||= new
@@ -29,24 +51,35 @@ module Rester
         instance.public_send(meth, *args, &block)
       end
 
-      ###
-      # Middleware DSL
-      ###
+      def versions
+        @__versions ||= constants.map(&:to_s).select { |c|
+          c.match(/^V\d{1,3}$/)
+        }.map(&:downcase).map(&:to_sym)
+      end
 
-      def use(klass, *args)
-        _middleware << [klass, *args]
+      def version_module(version)
+        (@__version_modules ||= {})[version.to_sym] ||= _load_version_module(version)
       end
 
-      def _middleware
-        @__middleware ||= BASE_MIDDLEWARE.dup
+      def _load_version_module(version)
+        versions.include?(version.to_sym) or
+          raise ArgumentError, "invalid version #{version.inspect}"
+
+        const_get(version.to_s.upcase)
       end
-    end # Class methods
 
-    attr_reader :request
+      def objects(version_module)
+        (@__objects ||= {})[version_module] ||= _load_objects(version_module)
+      end
 
-    def initialize(opts={})
-      @_opts = opts.dup
-    end
+      def _load_objects(version_module)
+        version_module.constants.map { |c|
+          version_module.const_get(c)
+        }.select { |c|
+          c.is_a?(Class) && c < Service::Object
+        }
+      end
+    end # Class methods
 
     ##
     # To be called by Rack. Wraps the app in middleware.
@@ -64,18 +97,12 @@ module Rester
     end
 
     ##
-    # Actually process the request.
+    # Process the request.
     #
     # Calls methods that may modify instance variables, so the instance should
     # be dup'd beforehand.
     def call!(env)
-      @request = Rack::Request.new(env)
-      _process_request
-    end
-
-    ##
-    # Built in service method called by Client#connected?
-    def test_connection(params={})
+      _process_request(Request.new(env))
     end
 
     private
@@ -91,45 +118,90 @@ module Rester
       }.to_app
     end
 
-    def _process_request
-      error!(Errors::NotFoundError) unless request.get? || request.post?
-      method, *args = _parse_path
-      params = _parse_params
-      method = "#{method}!" if request.post?
-      retval = public_send(method, *args, params)
+    ##
+    # Validates the request, calls the appropriate Service::Object method and
+    # returns a valid Rack response.
+    def _process_request(request)
+      _error!(Errors::NotFoundError) unless request.valid?
+      _validate_version(request)
+      retval = _call_method(request)
       _response(request.post? ? 201 : 200, _prepare_response(retval))
     end
 
-    def _prepare_response(retval)
-      retval ||= {}
-
-      unless retval.is_a?(Hash)
-        error!(Errors::ServerError, "Invalid response: #{retval.inspect}")
+    ##
+    # Validates that the version of the request matches a defined version module.
+    # 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)
       end
+    end
 
-      JSON.dump(retval)
+    ##
+    # Calls the appropriate method on the appropriate Service::Object for the
+    # request.
+    def _call_method(request)
+      params = request.params
+      retval = nil
+
+      name, id, *object_chain = request.object_chain
+      obj = _load_object(request, name)
+
+      loop {
+        obj = obj.new(id) if id
+
+        if object_chain.empty?
+          retval = obj.process(request.request_method, params)
+          break
+        end
+
+        params.merge!(obj.id_param => obj.id)
+        name, id, *object_chain = object_chain
+        obj = obj.mounts[name] or raise Errors::NotFoundError
+      }
+
+      retval
     end
 
-    def _parse_path
-      path = request.path
-      uri = URI(path)
-      uri.path.split('/')[1..-1]
+    ##
+    # Loads the appropriate Service::Object for the request. This will return
+    # the class, not an instance.
+    def _load_object(request, name)
+      _version_module(request).const_get(name.camelcase.singularize)
+    rescue NameError
+      _error!(Errors::NotFoundError)
     end
 
-    def _parse_params
-      if request.get?
-        request.GET
-      elsif request.post?
-        request.POST
+    ##
+    # Returns the module specified by the version in the request.
+    def _version_module(request)
+      self.class.version_module(request.version)
+    end
+
+    ##
+    # Prepares the retval from a Service::Object 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
+
+      JSON.dump(retval)
     end
 
-    def _response(status, body=EmptyResponse, headers={})
-      body = body == EmptyResponse ? [] : [body]
+    ##
+    # Returns a valid rack response.
+    def _response(status, body=nil, headers={})
+      body = [body].compact
       headers = headers.merge("Content-Type" => "application/json")
       Rack::Response.new(body, status, headers).finish
     end
 
+    ##
+    # Throws an exception (instead of raising it). This is done for performance
+    # reasons. The exception will be caught in the ErrorHandling middleware.
     def _error!(klass, message=nil)
       Errors.throw_error!(klass, message)
     end

data/lib/rester/utils.rb

@@ -16,6 +16,11 @@ module Rester
         end
       end
 
+      def join_paths(*paths)
+        paths.map(&:to_s).reject { |p| p.nil? || p.empty? }
+          .join('/').gsub(/\/+/, '/')
+      end
+
       def walk(object, context=nil, &block)
         case object
         when Hash

data/lib/rester/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rester
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-29 00:00:00.000000000 Z
+date: 2015-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -31,6 +31,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.13
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -89,8 +103,8 @@ dependencies:
         version: 4.0.0
 description: A framework for creating simple RESTful interfaces between services.
 email:
-- robert@ribbonpayments.com
-- kayvon@ribbon.co
+- robert@payout.com
+- kayvon@payout.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -101,15 +115,19 @@ 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/resource.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/railtie.rb
 - lib/rester/service.rb
+- lib/rester/service/object.rb
+- lib/rester/service/request.rb
 - lib/rester/utils.rb
 - lib/rester/version.rb
-homepage: http://github.com/ribbon/rester
+homepage: http://github.com/payout/rester
 licenses:
 - BSD
 metadata: {}