rester 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 891fe3d740381cb54c48e89ad69fca06e1fc06d6
+  data.tar.gz: db402da2918dc425d879b3719fc41e976b1de4bf
+SHA512:
+  metadata.gz: 1a4992cf642165b17d1e77e854ac9fdaadef82ccc45337548d0a902048bb372dc9574713ff5109f5baba43e3f0c730b1c299c005932314d1ff5bc803ca6d087b
+  data.tar.gz: 4b9ef3355867f57f67632b24dffd84b9d39027d94544d8681058b27e01fe204418dc04b3a9b843ad48fdcf9b412460dda07707bdfbc74ed77bac057b38a347e2

data/lib/rester.rb

@@ -0,0 +1,23 @@
+require 'rester/version'
+require 'rack'
+
+module Rester
+  require 'rester/railtie' if defined?(Rails)
+  autoload(:Service,     'rester/service')
+  autoload(:Errors,      'rester/errors')
+  autoload(:Client,      'rester/client')
+  autoload(:Utils,       'rester/utils')
+  autoload(:Middleware,  'rester/middleware')
+
+  class << self
+    def load_tasks
+      Dir[
+        File.expand_path("../../tasks", __FILE__) + '/**.rake'
+      ].each { |rake_file| load rake_file }
+    end
+
+    def connect(*args)
+      Client.new(*args)
+    end
+  end # Class Methods
+end # Rester

data/lib/rester/client.rb

@@ -0,0 +1,61 @@
+require 'json'
+
+module Rester
+  class Client
+    autoload(:Adapters, 'rester/client/adapters')
+
+    attr_reader :adapter
+
+    def initialize(*args)
+      case args.first
+      when Adapters::Adapter
+        self.adapter = args.first
+      else
+        self.adapter = Adapters::HttpAdapter.new(*args)
+      end
+    end
+
+    def connect(*args)
+      adapter.connect(*args)
+    end
+
+    def connected?
+      adapter.connected? && adapter.get(:test_connection).first == 200
+    end
+
+    protected
+
+    def adapter=(adapter)
+      @adapter = adapter
+    end
+
+    private
+
+    ##
+    # 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))
+    end
+
+    def _process_response(meth, 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
+      else
+        raise Errors::ServerError, _parse_json(body)[:message]
+      end
+    end
+
+    def _parse_json(data)
+      if data.is_a?(String) && !data.empty?
+        JSON.parse(data, symbolize_names: true)
+      else
+        {}
+      end
+    end
+  end # Client
+end # Rester

data/lib/rester/client/adapters.rb

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

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

@@ -0,0 +1,114 @@
+module Rester
+  module Client::Adapters
+    class Adapter
+      def initialize(*args)
+        connect(*args) unless args.empty?
+      end
+
+      ##
+      # Returns the headers defined for this Adapter. Optionally, you may also
+      # define additional headers you'd like to add/override.
+      def headers(new_headers={})
+        (@headers ||= {}).merge!(new_headers)
+      end
+
+      ##
+      # Connect to a service. The specific arguments depend on the Adapter
+      # subclass.
+      def connect(*args)
+        raise NotImplementedError
+      end
+
+      ##
+      # Returns whether or not the Adapter is connected to a service.
+      def connected?
+        raise NotImplementedError
+      end
+
+      def request(verb, method, *args, &block)
+        _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
+        )
+      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
+
+      def post!(path, params={})
+        raise NotImplementedError
+      end
+
+      protected
+
+      def headers=(h)
+        @headers = h
+      end
+
+      private
+
+      VALID_VERBS = {
+        get: true,
+        post: 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
+
+      VALID_PARAM_VALUE_TYPES = {
+        String   => true,
+        Symbol   => true,
+        Fixnum   => true,
+        Integer  => true,
+        Float    => true,
+        DateTime => true
+      }.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}"
+        }
+      end
+    end # Adapter
+  end # Client::Adapters
+end # Rester

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

@@ -0,0 +1,31 @@
+module Rester
+  module Client::Adapters
+    class HttpAdapter < Adapter
+      autoload(:Connection, 'rester/client/adapters/http_adapter/connection')
+
+      attr_reader :connection
+
+      def connect(*args)
+        nil.tap { @connection = Connection.new(*args) }
+      end
+
+      def connected?
+        !!connection
+      end
+
+      def get!(path, params={})
+        _prepare_response(connection.get(path, headers: headers, query: params))
+      end
+
+      def post!(path, params={})
+        _prepare_response(connection.post(path, headers: headers, data: params))
+      end
+
+      private
+
+      def _prepare_response(response)
+        [response.code.to_i, response.body]
+      end
+    end # HttpAdapter
+  end # Client::Adapters
+end # Rester

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

@@ -0,0 +1,58 @@
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+module Rester
+  module Client::Adapters
+    class HttpAdapter::Connection
+      DEFAULT_POST_HEADERS = {
+        "Content-Type".freeze => "application/x-www-form-urlencoded".freeze
+      }.freeze
+
+      attr_reader :url
+
+      def initialize(url)
+        @url = url.is_a?(String) ? URI(url) : url
+        @url.path = @url.path[0..-2] if @url.path[-1] == '/'
+      end
+
+      def get(path, params={})
+        _http.get(
+          _path(path, params[:query]),
+          _prepare_headers(params[:headers])
+        )
+      end
+
+      def post(path, params={})
+        headers = DEFAULT_POST_HEADERS.merge(_prepare_headers(params[:headers]))
+        encoded_data = URI.encode_www_form(params[:data] || {})
+        _http.post(_path(path), encoded_data, headers)
+      end
+
+      private
+
+      def _path(path, query=nil)
+        u = url.dup
+        u.path += path
+        u.query = URI.encode_www_form(query) if query && !query.empty?
+        u.request_uri
+      end
+
+      def _http
+        Net::HTTP.new(url.hostname, url.port).tap { |http|
+          if (http.use_ssl=url.is_a?(URI::HTTPS))
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+            http.cert_store = OpenSSL::X509::Store.new.tap { |s|
+              s.set_default_paths
+            }
+          end
+        }
+      end
+
+      def _prepare_headers(headers)
+        Hash[(headers || {}).map { |k, v| [k.to_s, v.to_s] }]
+      end
+    end # HttpAdapter::Connection
+  end # Client::Adapters
+end # Rester

data/lib/rester/errors.rb

@@ -0,0 +1,52 @@
+module Rester
+  module Errors
+    class << self
+      ##
+      # Throws an error instead of raising it, which is more performant. Must
+      # be caught by an appropriate error handling wrapper.
+      def throw_error!(klass, message=nil)
+        error = message ? klass.new(message) : klass.new
+        throw :error, error
+      end
+    end # Class Methods
+
+    class Error < StandardError; end
+
+    ##
+    # Packet errors
+    class PacketError < Error; end
+    class InvalidEncodingError < PacketError; end
+
+    #############
+    # Http Errors
+    class HttpError < Error; end
+
+    ##
+    # Request Errors
+
+    # 400 Error
+    class RequestError < HttpError; end
+
+    # 401 Error
+    class AuthenticationError < RequestError; end
+
+    # 403 Error
+    class ForbiddenError < RequestError; end
+
+    # 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.rb

@@ -0,0 +1,6 @@
+module Rester
+  module Middleware
+    autoload(:Base,          'rester/middleware/base')
+    autoload(:ErrorHandling, 'rester/middleware/error_handling')
+  end
+end

data/lib/rester/middleware/base.rb

@@ -0,0 +1,44 @@
+module Rester
+  module Middleware
+    class Base
+      attr_reader :app
+      attr_reader :options
+
+      def initialize(app, options = {})
+        @app = app
+        @options = options
+      end
+
+      def call(env)
+        app.call(env)
+      end
+
+      def service
+        @__service ||= _find_service
+      end
+
+      private
+
+      def _find_service
+        service = app
+
+        loop {
+          break if service.is_a?(Service)
+
+          [:app, :target].each { |meth|
+            if service.respond_to?(meth)
+              service = service.public_send(meth)
+              break
+            end
+          }
+        }
+
+        service.is_a?(Service) && service
+      end
+
+      def _error!(klass, message=nil)
+        Errors.throw_error!(klass, message)
+      end
+    end # Base
+  end # Middleware
+end # Rester

data/lib/rester/middleware/error_handling.rb

@@ -0,0 +1,49 @@
+require 'json'
+
+module Rester
+  module Middleware
+    ##
+    # Provides error handling for Rester. Should be mounted above all other
+    # Rester middleware.
+    class ErrorHandling < Base
+      def call(env)
+        error = catch(:error) {
+          begin
+            return super
+          rescue Exception => error
+            throw :error, error
+          end
+        }
+
+        _error_to_response(error).finish
+      end
+
+      private
+
+      def _error_to_response(error)
+        Rack::Response.new(
+          [JSON.dump(message: error.message)],
+          _error_to_http_code(error),
+          { "Content-Type" => "application/json"}
+        )
+      end
+
+      def _error_to_http_code(error)
+        case error
+        when Errors::NotFoundError
+          404
+        when Errors::ForbiddenError
+          403
+        when Errors::AuthenticationError
+          401
+        when Errors::RequestError
+          400
+        when Errors::ServerError
+          500
+        else
+          500
+        end
+      end
+    end # ErrorHandling
+  end # Middleware
+end # Rester

data/lib/rester/railtie.rb

@@ -0,0 +1,12 @@
+require 'rester'
+require 'rails'
+
+module Rester
+  class Railtie < Rails::Railtie
+    railtie_name :rester
+
+    rake_tasks do
+      Rester.load_tasks
+    end
+  end
+end

data/lib/rester/service.rb

@@ -0,0 +1,137 @@
+require 'uri'
+require 'rack'
+
+module Rester
+  class Service
+    ##
+    # The base set of middleware to use for every service.
+    # Middleware will be executed in the order specified.
+    BASE_MIDDLEWARE = [
+      Rack::Head,
+      Middleware::ErrorHandling
+    ].freeze
+
+    # Used to signify an empty body
+    class EmptyResponse; end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      # The call method needs to call the rack_call method, which adds additional
+      # rack middleware.
+      def call(env)
+        instance.rack_call(env)
+      end
+
+      def method_missing(meth, *args, &block)
+        instance.public_send(meth, *args, &block)
+      end
+
+      ###
+      # Middleware DSL
+      ###
+
+      def use(klass, *args)
+        _middleware << [klass, *args]
+      end
+
+      def _middleware
+        @__middleware ||= BASE_MIDDLEWARE.dup
+      end
+    end # Class methods
+
+    attr_reader :request
+
+    def initialize(opts={})
+      @_opts = opts.dup
+    end
+
+    ##
+    # To be called by Rack. Wraps the app in middleware.
+    def rack_call(env)
+      _rack_app.call(env)
+    end
+
+    ##
+    # Call the service app directly.
+    #
+    # Duplicates the instance before processing the request so individual requests
+    # can't impact each other.
+    def call(env)
+      dup.call!(env)
+    end
+
+    ##
+    # Actually 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={})
+    end
+
+    private
+
+    def _rack_app
+      @__rack_app ||= _build_rack_app
+    end
+
+    def _build_rack_app
+      Rack::Builder.new.tap { |app|
+        self.class._middleware.each { |m| app.use(*m) }
+        app.run self
+      }.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)
+      _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}")
+      end
+
+      JSON.dump(retval)
+    end
+
+    def _parse_path
+      path = request.path
+      uri = URI(path)
+      uri.path.split('/')[1..-1]
+    end
+
+    def _parse_params
+      if request.get?
+        request.GET
+      elsif request.post?
+        request.POST
+      end
+    end
+
+    def _response(status, body=EmptyResponse, headers={})
+      body = body == EmptyResponse ? [] : [body]
+      headers = headers.merge("Content-Type" => "application/json")
+      Rack::Response.new(body, status, headers).finish
+    end
+
+    def _error!(klass, message=nil)
+      Errors.throw_error!(klass, message)
+    end
+  end # Service
+end # Rester

data/lib/rester/utils.rb

@@ -0,0 +1,49 @@
+require 'date'
+
+module Rester
+  module Utils
+    class << self
+      ##
+      # Determines the HTTP method/verb based on the method name.
+      # Defaults to GET but if the method ends with "!" it uses POST.
+      def extract_method_verb(meth)
+        meth = meth.to_s
+
+        if meth[-1] == '!'
+          [:post, meth[0..-2]]
+        else
+          [:get, meth]
+        end
+      end
+
+      def walk(object, context=nil, &block)
+        case object
+        when Hash
+          Hash[
+            object.map { |key, val|
+              [walk(key, :hash_key, &block), walk(val, :hash_value, &block)]
+            }
+          ]
+        when Array
+          object.map { |obj| walk(obj, :array_elem, &block) }
+        when Range
+          Range.new(
+            walk(object.begin, :range_begin, &block),
+            walk(object.end, :range_end, &block),
+            object.exclude_end?
+          )
+        else
+          yield object, context
+        end
+      end
+
+      def symbolize_keys(hash)
+        hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      end
+
+      def classify(str)
+        str.to_s.split("_").map(&:capitalize).join
+      end
+    end # Class methods
+  end # Utils
+end # Rester

data/lib/rester/version.rb

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

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: rester
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Honer
+- Kayvon Ghaffari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: A framework for creating simple RESTful interfaces between services.
+email:
+- robert@ribbonpayments.com
+- kayvon@ribbon.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rester.rb
+- lib/rester/client.rb
+- lib/rester/client/adapters.rb
+- lib/rester/client/adapters/adapter.rb
+- lib/rester/client/adapters/http_adapter.rb
+- lib/rester/client/adapters/http_adapter/connection.rb
+- lib/rester/errors.rb
+- lib/rester/middleware.rb
+- lib/rester/middleware/base.rb
+- lib/rester/middleware/error_handling.rb
+- lib/rester/railtie.rb
+- lib/rester/service.rb
+- lib/rester/utils.rb
+- lib/rester/version.rb
+homepage: http://github.com/ribbon/rester
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A framework for creating simple RESTful interfaces between services.
+test_files: []