restfulness 0.1.0

data/lib/restfulness/resource.rb

@@ -0,0 +1,111 @@
+module Restfulness
+
+  class Resource
+
+    attr_reader :request, :response
+
+    def initialize(request, response)
+      @request  = request
+      @response = response
+    end
+
+    # Options is the only HTTP method support by default
+    def options
+      response.headers['Allow'] = self.class.supported_methods.map{ |m|
+        m.to_s.upcase
+      }.join(', ') 
+      nil
+    end
+
+    def call
+      send(request.action)
+    end
+
+    # Callbacks
+
+    def method_allowed?
+      self.class.supported_methods.include?(request.action)
+    end
+
+    def exists?
+      true
+    end
+
+    def authorized?
+      true
+    end
+
+    def allowed?
+      true
+    end
+
+    def last_modified
+      nil
+    end
+
+    def etag
+      nil
+    end
+
+    def check_callbacks
+      # Access control
+      raise HTTPException.new(405) unless method_allowed?
+      raise HTTPException.new(401) unless authorized?
+      raise HTTPException.new(403) unless allowed?
+
+      # The following callbacks only make sense for certain methods
+      if [:head, :get, :put, :delete].include?(request.action)
+
+        raise HTTPException.new(404) unless exists?
+
+        if [:get, :head].include?(request.action)
+          # Resource status
+          check_etag if etag
+          check_if_modified if last_modified
+        end
+      end
+    end
+
+    ##
+
+
+    protected
+
+    def error(code, payload = nil, opts = {})
+      raise HTTPException.new(code, payload, opts)
+    end
+
+    def logger
+      Restfulness.logger
+    end
+
+
+    private
+
+    def check_if_modified
+      date = request.headers[:if_modified_since]
+      if date && date == last_modified.to_s
+        raise HTTPException.new(304)
+      end
+      response.headers['Last-Modified'] = last_modified
+    end
+
+    def check_etag
+      tag = request.headers[:if_none_match]
+      if tag && tag == etag.to_s
+        raise HTTPException.new(304)
+      end
+      response.headers['ETag'] = etag
+    end
+
+    class << self
+
+      def supported_methods
+        @_actions ||= (instance_methods & [:get, :put, :post, :delete, :head, :patch, :options])
+      end
+
+    end
+
+  end
+
+end

data/lib/restfulness/response.rb

@@ -0,0 +1,57 @@
+
+module Restfulness
+
+  class Response
+
+    # Incoming data
+    attr_reader :request
+
+    # Outgoing data
+    attr_reader :code, :headers, :payload
+
+
+    def initialize(request)
+      @request = request
+
+      # Default headers
+      @headers = {'Content-Type' => 'application/json; charset=utf-8'}
+    end
+
+    def run
+      logger.info("Responding to #{request.action.to_s.upcase} #{request.uri.to_s} from #{request.remote_ip}")
+
+      route = request.route
+      if route
+        logger.info("Using resource: #{route.resource_name}")
+        resource = route.build_resource(request, self)
+
+        # run callbacks, if any fail, they'll raise an error
+        resource.check_callbacks
+
+        # Perform the actual work
+        result = resource.call
+
+        @code    ||= (result ? 200 : 204)
+        @payload   = MultiJson.encode(result)
+      else
+        logger.error("No route found")
+        # This is not something we can deal with, pass it on
+        @code    = 404
+        @payload = ""
+      end
+      update_content_length
+    end
+
+    def logger
+      Restfulness.logger
+    end
+
+    protected
+    
+    def update_content_length
+      @headers['Content-Length'] = @payload.bytesize.to_s
+    end
+
+  end
+
+end

data/lib/restfulness/route.rb

@@ -0,0 +1,48 @@
+module Restfulness
+
+  class Route
+
+    # The path array of eliments, :id always on end!
+    attr_accessor :path
+
+    # Reference to the class that will handle requests for this route
+    attr_accessor :resource_name
+
+    def initialize(*args)
+      self.resource_name = args.pop.to_s
+      self.path = args.reject{|arg| arg == :id}
+
+      if resource_name.empty? || resource.nil? # Try to load the resource
+        raise ArgumentError, "Please provide a resource!"
+      end
+    end
+
+    def build_path(path)
+      Path.new(self, path)
+    end
+
+    def handles?(parts)
+      # Make sure same length (accounting for id)
+      diff = parts.length - path.length
+      return false if diff != 0 && diff != 1
+
+      # Compare the pairs
+      path.each_with_index do |slug, i|
+        if slug.is_a?(String) or slug.is_a?(Numeric)
+          return false if parts[i] != slug.to_s
+        end
+      end
+      true
+    end
+
+    def resource
+      resource_name.constantize
+    end
+
+    def build_resource(request, response)
+      resource.new(request, response)
+    end
+
+  end
+
+end

data/lib/restfulness/router.rb

@@ -0,0 +1,27 @@
+
+module Restfulness
+
+  class Router
+
+    attr_accessor :routes
+
+    def initialize(&block)
+      self.routes = []
+      instance_eval(&block) if block_given?
+    end
+
+    def add(*args)
+      routes << Route.new(*args)
+    end
+
+    def route_for(path)
+      parts = path.gsub(/^\/|\/$/, '').split(/\//)
+      routes.each do |route|
+        return route if route.handles?(parts)
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/restfulness/statuses.rb

@@ -0,0 +1,71 @@
+module Restfulness
+
+  # 
+  # List of standard HTTP statuses blatently stolen from Ruby RestClient.
+  #
+  # https://github.com/rest-client/rest-client
+  #
+
+  STATUSES = {
+    100 => 'Continue',
+    101 => 'Switching Protocols',
+    102 => 'Processing', #WebDAV
+
+    200 => 'OK',
+    201 => 'Created',
+    202 => 'Accepted',
+    203 => 'Non-Authoritative Information', # http/1.1
+    204 => 'No Content',
+    205 => 'Reset Content',
+    206 => 'Partial Content',
+    207 => 'Multi-Status', #WebDAV
+
+    300 => 'Multiple Choices',
+    301 => 'Moved Permanently',
+    302 => 'Found',
+    303 => 'See Other', # http/1.1
+    304 => 'Not Modified',
+    305 => 'Use Proxy', # http/1.1
+    306 => 'Switch Proxy', # no longer used
+    307 => 'Temporary Redirect', # http/1.1
+
+    400 => 'Bad Request',
+    401 => 'Unauthorized',
+    402 => 'Payment Required',
+    403 => 'Forbidden',
+    404 => 'Resource Not Found',
+    405 => 'Method Not Allowed',
+    406 => 'Not Acceptable',
+    407 => 'Proxy Authentication Required',
+    408 => 'Request Timeout',
+    409 => 'Conflict',
+    410 => 'Gone',
+    411 => 'Length Required',
+    412 => 'Precondition Failed',
+    413 => 'Request Entity Too Large',
+    414 => 'Request-URI Too Long',
+    415 => 'Unsupported Media Type',
+    416 => 'Requested Range Not Satisfiable',
+    417 => 'Expectation Failed',
+    418 => 'I\'m A Teapot',
+    421 => 'Too Many Connections From This IP',
+    422 => 'Unprocessable Entity', #WebDAV
+    423 => 'Locked', #WebDAV
+    424 => 'Failed Dependency', #WebDAV
+    425 => 'Unordered Collection', #WebDAV
+    426 => 'Upgrade Required',
+    449 => 'Retry With', #Microsoft
+    450 => 'Blocked By Windows Parental Controls', #Microsoft
+
+    500 => 'Internal Server Error',
+    501 => 'Not Implemented',
+    502 => 'Bad Gateway',
+    503 => 'Service Unavailable',
+    504 => 'Gateway Timeout',
+    505 => 'HTTP Version Not Supported',
+    506 => 'Variant Also Negotiates',
+    507 => 'Insufficient Storage', #WebDAV
+    509 => 'Bandwidth Limit Exceeded', #Apache
+    510 => 'Not Extended'
+  }
+end

data/lib/restfulness/version.rb

@@ -0,0 +1,3 @@
+module Restfulness
+  VERSION = "0.1.0"
+end

data/restfulness.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'restfulness/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "restfulness"
+  spec.version       = Restfulness::VERSION
+  spec.authors       = ["Sam Lown"]
+  spec.email         = ["me@samlown.com"]
+  spec.description   = %q{Simple REST server that focuses on resources instead of routes.}
+  spec.summary       = %q{Use to create a powerful, yet simple REST API in your application.}
+  spec.homepage      = "https://github.com/samlown/restfulness"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rack", "~> 1.4"
+  spec.add_dependency "multi_json", "~> 1.8"
+  spec.add_dependency "activesupport", ">= 3.1"
+  spec.add_dependency "mono_logger", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'restfulness' # and any other gems you need
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+# Disable any logger output
+Restfulness.logger.formatter = proc {|severity, datetime, progname, msg| ""}
+

data/spec/unit/application_spec.rb

@@ -0,0 +1,91 @@
+
+require 'spec_helper'
+
+describe Restfulness::Application do
+
+  let :klass do
+    Class.new(Restfulness::Application) do
+      routes do
+        # nothing
+      end
+    end
+  end
+
+  describe "#router" do
+    it "should access class's router" do
+      obj = klass.new
+      obj.router.should eql(klass.router)
+    end
+  end
+
+  describe "#call" do
+    it "should build rack app and call with env" do
+      env = {}
+      obj = klass.new
+      app = double(:app)
+      app.should_receive(:call).with(env)
+      obj.should_receive(:build_rack_app).and_return(app)
+      obj.call(env)
+    end
+  end
+
+  describe "#build_rack_app (protected)" do
+    it "should build a new rack app with middlewares" do
+      obj = klass.new
+      app = obj.send(:build_rack_app)
+      app.should be_a(Rack::Builder)
+      # Note, this might brake if Rack changes!
+      app.instance_variable_get(:@use).first.call.should be_a(klass.middlewares.first)
+      app.instance_variable_get(:@run).should be_a(Restfulness::Dispatchers::Rack)
+    end
+  end
+
+  describe ".routes" do
+
+    context "basic usage" do
+      it "should build a new router with block" do
+        klass.router.should_not be_nil
+        klass.router.should be_a(Restfulness::Router)
+      end
+
+      it "should be accessable from instance" do
+        obj = klass.new
+        obj.router.should eql(klass.router)
+      end
+
+      it "should pass block to Router instance" do
+        block = lambda { }
+        Restfulness::Router.should_receive(:new).with(&block)
+        Class.new(Restfulness::Application) do
+          routes &block
+        end
+      end
+    end
+
+  end
+
+  describe ".middlewares" do
+    it "should provide simple array of middlewares" do
+      klass.middlewares.should be_a(Array)
+      klass.middlewares.should include(Rack::ShowExceptions)
+    end
+  end
+
+  describe ".logger" do
+    it "should return main logger" do
+      klass.logger.should eql(Restfulness.logger)
+    end
+  end
+
+  describe ".logger=" do
+    it "should set main logger" do
+      orig = Restfulness.logger
+      logger = double(:Logger)
+      klass.logger = logger
+      Restfulness.logger.should eql(logger)
+      Restfulness.logger = orig
+    end
+  end
+
+
+end