restfulness 0.1.0

data/example/app.rb

@@ -0,0 +1,42 @@
+
+require 'restfulness'
+
+$projects = []
+
+Project = Class.new(HashWithIndifferentAccess)
+
+class ProjectResource < Restfulness::Resource
+  def exists?
+    !project.nil?
+  end
+  def get
+    project
+  end
+  def post
+    $projects << Project.new(request.params)
+  end
+  def put
+    project.update(request.params)
+  end
+  def delete
+    $projects.delete(project)
+  end
+  protected
+  def project
+    $projects.find{|p| p[:id] == request.path[:id]}
+  end
+end
+
+class ProjectsResource < Restfulness::Resource
+  def get
+    $projects
+  end
+end
+
+
+class ExampleApp < Restfulness::Application
+  routes do
+    add 'project', ProjectResource
+    add 'projects', ProjectsResource
+  end
+end

data/example/config.ru

@@ -0,0 +1,5 @@
+
+require './app'
+
+run ExampleApp.new
+

data/lib/restfulness.rb

@@ -0,0 +1,36 @@
+
+require 'uri'
+require 'multi_json'
+require 'mono_logger'
+require 'active_support/core_ext'
+require 'active_support/dependencies'
+require 'rack/utils'
+require 'rack/showexceptions'
+require 'rack/builder'
+
+require "restfulness/application"
+require "restfulness/dispatcher"
+require "restfulness/exceptions"
+require "restfulness/path"
+require "restfulness/request"
+require "restfulness/resource"
+require "restfulness/response"
+require "restfulness/route"
+require "restfulness/router"
+require "restfulness/statuses"
+require "restfulness/version"
+
+require "restfulness/dispatchers/rack"
+
+require "restfulness/log_formatters/quiet_formatter"
+require "restfulness/log_formatters/verbose_formatter"
+
+module Restfulness
+  extend self
+
+  attr_accessor :logger
+end
+
+Restfulness.logger = MonoLogger.new(STDOUT)
+Restfulness.logger.formatter = Restfulness::VerboseFormatter.new
+

data/lib/restfulness/application.rb

@@ -0,0 +1,83 @@
+module Restfulness
+
+  # 
+  # The Restulness::Application is the starting point. It'll deal with 
+  # defining the initial configuration, and handle incoming requests
+  # from rack. 
+  #
+  # Build your own Restfulness applications by inheriting from this class:
+  #
+  #   class MyApp < Restfulness::Application
+  #
+  #     routes do
+  #       scope 'api' do
+  #         add 'journey', JourneyResource
+  #         add 'journeys', JourneyCollectionResource
+  #       end
+  #     end
+  #
+  #   end
+  #
+  class Application
+
+    def router
+      self.class.router
+    end
+
+    # Rack Handling.
+    # Forward rack call to dispatcher
+    def call(env)
+      @app ||= build_rack_app
+      @app.call(env)
+    end
+
+    protected
+
+    def build_rack_app
+      this = self
+      dispatcher = Dispatchers::Rack.new(self)
+      Rack::Builder.new do
+        this.class.middlewares.each do |middleware|
+          use middleware
+        end
+        run dispatcher
+      end
+    end
+
+    class << self
+
+      attr_accessor :router, :middlewares
+
+      def routes(&block)
+        # Store the block so we can parse it at run time (autoload win!)
+        @router = Router.new(&block)
+      end
+
+      # A simple array of rack middlewares that will be applied
+      # before handling the request in Restfulness.
+      #
+      # Probably most useful for adding the ActiveDispatch::Reloader
+      # as used by Rails to reload on each request. e.g.
+      #
+      #    middlewares << ActiveDispatch::Reloader
+      #
+      def middlewares
+        @middlewares ||= [
+          Rack::ShowExceptions
+        ]
+      end
+
+      # Quick access to the Restfulness logger.
+      def logger
+        Restfulness.logger
+      end
+
+      # Override the default Restfulness logger.
+      def logger=(logger)
+        Restfulness.logger = logger
+      end
+
+    end
+
+  end
+end

data/lib/restfulness/dispatcher.rb

@@ -0,0 +1,14 @@
+
+module Restfulness
+
+  class Dispatcher
+
+    attr_accessor :app
+
+    def initialize(app)
+      self.app = app
+    end
+
+  end
+
+end

data/lib/restfulness/dispatchers/rack.rb

@@ -0,0 +1,91 @@
+module Restfulness
+
+  module Dispatchers
+
+    class Rack < Dispatcher
+
+      def call(env)
+        rack_req = ::Rack::Request.new(env)
+
+        # Make sure we understand the request
+        request = Request.new(app)
+        prepare_request(env, rack_req, request)
+
+
+        # Prepare a suitable response
+        response = Response.new(request)
+        response.run
+
+
+        # No need to provide an empty response
+        log_response(response.code)
+        [response.code, response.headers, [response.payload || ""]]
+
+      rescue HTTPException => e
+        log_response(e.code)
+        [e.code, {}, [e.payload || ""]]
+
+      #rescue Exception => e
+      #  log_response(500)
+      #  puts
+      #  puts e.message
+      #  puts e.backtrace
+      #  # Something unknown went wrong
+      #  [500, {}, [STATUSES[500]]]
+      end
+
+      protected
+
+      def prepare_request(env, rack_req, request)
+        request.uri       = rack_req.url
+        request.action    = parse_action(rack_req.request_method)
+        request.query     = rack_req.GET
+        request.body      = rack_req.body
+        request.remote_ip = rack_req.ip
+        request.headers   = prepare_headers(env)
+
+        # Sometimes rack removes content type from headers
+        request.headers[:content_type] ||= rack_req.content_type
+      end
+
+      def parse_action(action)
+        case action
+        when 'DELETE'
+          :delete
+        when 'GET'
+          :get
+        when 'HEAD'
+          :head
+        when 'POST'
+          :post
+        when 'PUT'
+          :put
+        when 'OPTIONS'
+          :options
+        else
+          raise HTTPException.new(501)
+        end
+      end
+
+      def log_response(code)
+        logger.info("Completed #{code} #{STATUSES[code]}")
+      end
+
+      def prepare_headers(env)
+        res = {}
+        env.each do |k,v|
+          next unless k =~ /^HTTP_/
+          res[k.sub(/^HTTP_/, '').downcase.gsub(/-/, '_').to_sym] = v
+        end
+        res
+      end
+
+      def logger
+        Restfulness.logger
+      end
+
+    end
+
+  end
+
+end

data/lib/restfulness/exceptions.rb

@@ -0,0 +1,17 @@
+
+module Restfulness
+
+  class HTTPException < ::StandardError
+
+    attr_accessor :code, :payload, :headers
+
+    def initialize(code, payload = nil, opts = {})
+      @code    = code
+      @payload = payload
+      @headers = opts[:headers]
+      super(opts[:message] || STATUSES[code])
+    end
+
+  end
+
+end

data/lib/restfulness/log_formatters/quiet_formatter.rb

@@ -0,0 +1,7 @@
+module Restfulness
+  class QuietFormatter
+    def call(serverity, datetime, progname, msg)
+      ""
+    end
+  end
+end

data/lib/restfulness/log_formatters/verbose_formatter.rb

@@ -0,0 +1,16 @@
+module Restfulness
+  class VerboseFormatter
+    def call(serverity, datetime, progname, msg)
+      time = Time.now.strftime('%Y-%m-%d %H:%M:%S.%L')
+      sym = case serverity
+            when 'ERROR'
+              'EE'
+            when 'INFO'
+              '--'
+            else
+              '**'
+            end
+      "#{sym} #{time}: #{msg}\n"
+    end
+  end
+end

data/lib/restfulness/path.rb

@@ -0,0 +1,46 @@
+
+module Restfulness
+
+  # The Path object is provided in request objects to provide easy access
+  # to parameters included in the URI's path.
+  class Path
+
+    attr_accessor :route, :components, :params
+
+    def initialize(route, string)
+      self.route  = route
+      self.params = {}
+      parse(string)
+    end
+
+    def to_s
+      '/' + components.join('/')
+    end
+
+    def [](index)
+      if index.is_a?(Integer)
+        components[index]
+      else
+        params[index]
+      end
+    end
+
+    protected
+
+    def parse(string)
+      self.components = string.gsub(/^\/|\/$/, '').split(/\//)
+
+      # Make sure we have the id available when parsing
+      path = route.path + [:id]
+
+      # Parametize values that need it
+      path.each_with_index do |value, i|
+        if value.is_a?(Symbol)
+          params[value] = components[i]
+        end
+      end
+    end
+
+  end
+
+end

data/lib/restfulness/request.rb

@@ -0,0 +1,81 @@
+module Restfulness
+
+  # Simple, indpendent, request interface for dealing with the incoming information
+  # in a request. 
+  #
+  # Currently wraps around the information provided in a Rack Request object.
+  class Request
+
+    # Who does this request belong to?
+    attr_reader :app
+
+    # The HTTP action being handled
+    attr_accessor :action
+
+    # Hash of HTTP headers. Keys always normalized to lower-case symbols with underscore.
+    attr_accessor :headers
+
+    # Ruby URI object
+    attr_reader :uri
+
+    # Path object of the current URL being accessed
+    attr_accessor :path
+
+    # The route, determined from the path, if available!
+    attr_accessor :route
+
+    # Query parameters included in the URL
+    attr_accessor :query
+
+    # Raw HTTP body, for POST and PUT requests.
+    attr_accessor :body
+
+    # IP address of requester
+    attr_accessor :remote_ip
+
+    def initialize(app)
+      @app = app
+
+      # Prepare basics
+      self.action  = nil
+      self.headers = {}
+      self.body    = nil
+    end
+
+    def uri=(uri)
+      @uri = URI(uri)
+    end
+
+    def path
+      @path ||= (route ? route.build_path(uri.path) : nil)
+    end
+
+    def route
+      # Determine the route from the uri
+      @route ||= app.router.route_for(uri.path)
+    end
+
+    def query
+      @query ||= HashWithIndifferentAccess.new(
+        ::Rack::Utils.parse_nested_query(uri.query)
+      )
+    end
+
+    def params
+      return @params if @params || body.nil?
+      case headers[:content_type]
+      when 'application/json'
+        @params = MultiJson.decode(body)
+      else
+        raise HTTPException.new(406)
+      end
+    end
+
+    [:get, :post, :put, :delete, :head, :options].each do |m|
+      define_method("#{m}?") do
+        action == m
+      end
+    end
+
+  end
+end