raisin 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in raisin.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 ccocchi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Raisin
+
+Elegant, modular and performant APIs in Rails
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'raisin'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install raisin
+
+## Usage
+
+Soon
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/raisin/api.rb

@@ -0,0 +1,251 @@
+module Raisin
+  class MiddlewareStack < ActionDispatch::MiddlewareStack
+    class Middleware < ActionDispatch::MiddlewareStack::Middleware
+      def update(args)
+        @args = args
+      end
+    end
+
+    def build(action, app=nil, &block)
+      super(app, &block)
+    end
+  end
+
+  class API
+    class_attribute :middleware_stack
+    self.middleware_stack = Raisin::MiddlewareStack.new
+
+    def self.action(name, klass = ActionDispatch::Request)
+      middleware_stack.build(name) do |env|
+        self.const_get(name.camelize).new.dispatch(:call, klass.new(env))
+      end
+    end
+
+    def self.use(*args, &block)
+      middleware_stack.use(*args, &block)
+    end
+
+    def self.action_klass
+      @_klass ||= begin
+        klass = Class.new(::Raisin::Base)
+        klass.send(:include, Raisin::Mixin)
+
+        if Configuration.enable_auth_by_default && Configuration.default_auth_method
+          klass.send(:before_filter, Configuration.default_auth_method)
+        end
+
+        klass.send(:respond_to, *Configuration.response_formats)
+        klass
+      end
+    end
+
+    def self.action_klass=(klass)
+      @_klass = klass
+    end
+
+    def self.reset
+      @_routes = []
+      @_prefix = self.api_name
+      @_namespaces = []
+      @_single_resource = false
+    end
+
+    def self.inherited(subclass)
+      subclass.reset
+      subclass.middleware_stack = self.middleware_stack.dup
+      subclass.action_klass = self.action_klass.dup
+      super
+    end
+
+    def self.api_name
+      @api_name ||= self.name.demodulize.sub(/api/i, '').underscore
+    end
+
+    def self.use_or_update(klass, *args)
+      m = middleware_stack.find { |m| m == klass }
+      if m
+        m.update klass.merge(m.args, args)
+      else
+        self.use(klass, *args)
+      end
+    end
+
+    def self.routes
+      @_routes
+    end
+
+    module DSL
+      %w(get head post put delete).each do |via|
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{via}(path = '/', options = {}, &block)
+            path = normalize_path(path)
+            method_name = options.key?(:as) ? options[:as].to_s : extract_method_name(path, :#{via})
+
+            klass = self.const_set method_name.camelize, Class.new(@_klass, &block)
+            klass.send(:expose, current_namespace.exposure, &(current_namespace.lazy_expose)) if current_namespace.try(:expose?)
+
+            current_namespace.add(method_name) if current_namespace
+
+            routes << [:#{via}, path, default_route(method_name)]
+          end
+        EOF
+      end
+
+      def included(&block)
+        self.action_klass.class_eval(&block) if block_given?
+      end
+
+      def member(&block)
+        namespace(':id') do
+          resource = self.api_name.singularize
+          expose(resource) { resource.camelize.constantize.send :find, params[:id] }
+          instance_eval(&block)
+        end
+      end
+
+      def nested_into_resource(parent)
+        parent = parent.to_s
+        sing = parent.singularize
+        id = "#{sing}_id"
+
+        @_namespaces << Namespace.new("#{parent}/:#{id}")
+        current_namespace.expose(sing) { sing.camelize.constantize.send :find, params[id.to_sym]}
+        @_namespaces << Namespace.new(@_prefix)
+        @_prefix = nil
+      end
+
+      def single_resource
+        @_single_resource = true
+        @_prefix = @_prefix.singularize if prefix?
+      end
+
+      def prefix(prefix)
+        @_prefix = prefix
+      end
+
+      def description(desc)
+        # noop
+      end
+
+      def expose(*args, &block)
+        current_namespace.expose(*args, &block)
+      end
+
+      def namespace(path, &block)
+        path = path.sub(%r(\A/?#{@_prefix}), '') if prefix?
+        @_namespaces.push Namespace.new(path)
+        yield
+        process_filters
+        @_namespaces.pop
+      end
+
+      %w(before around after).each do |type|
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{type}(*args, &block)
+            return unless current_namespace
+            current_namespace.filter(:#{type}, args, &block)
+          end
+        EOF
+      end
+
+      protected
+
+      def prefix?
+        !!@_prefix
+      end
+
+      def single_resource?
+        !!@_single_resource
+      end
+
+      def current_namespace
+        @_namespaces.at(0)
+      end
+
+      def current_namespace?
+        @_namespaces.length > 0
+      end
+
+      def process_filters
+        current_namespace.filters.each_pair { |type, filters|
+          filters.each do |name, block|
+            superclass.send("#{type}_filter", name, only: current_namespace.methods, &block)
+          end
+        }
+      end
+
+      def default_route(method)
+        "#{modules_prefix}#{self.api_name}##{method}"
+      end
+
+      def modules_prefix
+        @modules_prefix ||= begin
+          modules = self.name.split('::').slice(0..-2)
+          modules.empty? ? '' : "#{modules.map!(&:downcase).join('/')}/"
+        end
+      end
+
+      #
+      # Get method name from path
+      # Example:
+      #   / => :index
+      #   /users/:id => :users
+      #   /users/:id/addresses => :addresses
+      #
+      def extract_method_name(path, via)
+        return method_name_for_single_resource(path, via) if single_resource?
+
+        if path =~ %r(\A/?#{@_prefix}\z)
+          return via == :get ? 'index' : 'create'
+        end
+
+        parts = path.split('/').reverse!
+
+        return parts.find { |part| !part.start_with?(':') } if parts.first != ':id'
+
+        case via
+        when :get
+          'show'
+        when :put
+          'update'
+        when :delete
+          'destroy'
+        else
+          raise "Cannot extract method name from #{path}"
+        end
+      end
+
+      def method_name_for_single_resource(path, via)
+        if path =~ %r(\A/?#{@_prefix}\z)
+          case via
+          when :get
+            'show'
+          when :post
+            'create'
+          when :put
+            'update'
+          when :delete
+            'destroy'
+          end
+        else
+          path.split('/').reverse!.last
+        end
+      end
+
+      #
+      # Creates path with version, namespace and
+      # given path, then normalizes it
+      #
+      def normalize_path(path)
+        parts = []
+        parts << @_prefix unless !prefix? || path =~ %r(\A/?#{@_prefix})
+        parts.concat @_namespaces.reject { |n| path =~ %r(/#{n.path}) }.map!(&:path) if current_namespace?
+        parts << path.to_s unless path == '/'
+        parts.join('/')
+      end
+    end
+
+    extend DSL
+
+  end
+end

data/lib/raisin/base.rb

@@ -0,0 +1,237 @@
+module Raisin
+  class Base < ActionController::Metal
+    abstract!
+
+    module Compatibility
+      def cache_store; end
+      def cache_store=(*); end
+      def assets_dir=(*); end
+      def javascripts_dir=(*); end
+      def stylesheets_dir=(*); end
+      def page_cache_directory=(*); end
+      def asset_path=(*); end
+      def asset_host=(*); end
+      def relative_url_root=(*); end
+      def perform_caching=(*); end
+      def helpers_path=(*); end
+      def allow_forgery_protection=(*); end
+      # def helper_method(*); end
+      # def helper(*); end
+    end
+
+    extend Compatibility
+
+    MODULES = [
+      AbstractController::Helpers,
+      ActionController::UrlFor,
+      ActionController::Rendering,
+      ActionController::Renderers::All,
+
+      ActionController::ConditionalGet,
+
+      ActionController::RackDelegation,
+      ActionController::MimeResponds,
+      ActionController::ImplicitRender,
+      ActionController::DataStreaming,
+
+      AbstractController::Callbacks,
+      ActionController::Rescue,
+
+      ActionController::Instrumentation
+    ]
+
+    MODULES.each { |mod|
+      include mod
+    }
+
+    def self._expose(name, &block)
+
+    end
+
+    def self.controller_path
+      @controller_path ||= name && name.sub(/\:\:[^\:]+$/, '').sub(/api$/i, '').underscore
+    end
+
+    #
+    # Remove nil prefixes from our anonymous classes
+    #
+    def _prefixes
+      @_prefixes ||= begin
+        parent_prefixes = self.class.parent_prefixes
+        parent_prefixes.compact.unshift(controller_path)#.map! { |pr| pr.split('/').last }
+      end
+    end
+
+    def action_name
+      self.class.name.demodulize.underscore
+    end
+
+    #
+    # `call` is the only method to be processed. #process is not
+    # called in the normal process only in tests
+    #
+    def process(action, *args)
+      super(:call, *args)
+    end
+
+    # class << self
+    #   attr_internal_reader :routes, :current_namespace
+
+    #   alias :current_namespace? :current_namespace
+
+    #   %w(get head post put delete).each do |via|
+    #     class_eval <<-EOF, __FILE__, __LINE__ + 1
+    #       def #{via}(path, options = nil, &block)
+    #         path = normalize_path(path)
+    #         method_name = extract_method_name(path, :#{via})
+
+    #         endpoint = Endpoint.new
+    #         endpoint.instance_eval(&block)
+
+    #         Rails.logger.warn("WARNING: redefinition of method " << method_name) if method_defined?(method_name)
+    #         define_method(method_name, &(endpoint.response_body))
+
+    #         current_namespace.add(method_name) if current_namespace?
+
+    #         routes << [:#{via}, path, default_route(method_name)]
+    #       end
+    #     EOF
+    #   end
+
+    #   def prefix(prefix)
+    #     @_prefix = prefix
+    #   end
+
+    #   def prefix?
+    #     @_prefix
+    #   end
+
+    #   def description(desc)
+    #     # noop
+    #   end
+
+    #   # def get(path, options = nil, &block)
+    #   #   path = normalize_path(path)
+    #   #   method_name = extract_method_name(path, :get)
+
+    #   #   endpoint = Endpoint.new
+    #   #   endpoint.instance_eval(&block)
+
+    #   #   define_method(method_name, &(endpoint.response_body))
+
+    #   #   current_namespace.add(method_name) if current_namespace?
+
+    #   #   routes << [:get, path, default_route(method_name)]
+    #   # end
+    #   # alias_method :head, :get
+
+    #   # def post(path, options = nil, &block)
+    #   #   path = normalize_path(path)
+    #   #   method_name = extract_method_name(path)
+
+    #   #   define_method(method_name, &block)
+
+    #   #   routes << [:post, path, default_route(method_name)]
+    #   # end
+
+    #   # def put(path, options = nil, &block)
+    #   #   path = normalize_path(path)
+    #   #   method_name = extract_method_name(path)
+
+    #   #   define_method(method_name, &block)
+
+    #   #   routes << [:put, path, default_route(method_name)]
+    #   # end
+    #   # alias_method :patch, :put
+
+    #   # def delete(path, options = nil, &block)
+    #   #   path = normalize_path(path)
+    #   #   method_name = extract_method_name(path)
+
+    #   #   define_method(method_name, &block)
+
+    #   #   routes << [:delete, path, default_route(method_name)]
+    #   # end
+
+    #   def namespace(path, &block)
+    #     path = path.sub(%r(\A/?#{@_prefix}), '') if prefix?
+    #     old_namespace, @_current_namespace = current_namespace, Namespace.new(path)
+    #     yield
+    #     process_filters
+    #     @_current_namespace = old_namespace
+    #   end
+
+    #   %w(before around after).each do |type|
+    #     class_eval <<-EOF, __FILE__, __LINE__ + 1
+    #       def #{type}(*args, &block)
+    #         return unless current_namespace?
+    #         current_namespace.filter(:#{type}, args, &block)
+    #       end
+    #     EOF
+    #   end
+
+    #   protected
+
+    #   def process_filters
+    #     current_namespace.filters.each_pair { |type, filters|
+    #       filters.each do |name, block|
+    #         superclass.send("#{type}_filter", name, only: current_namespace.methods, &block)
+    #       end
+    #     }
+    #   end
+
+    #   def default_route(method)
+    #     "#{modules_prefix}#{self.api_name}##{method}"
+    #   end
+
+    #   def modules_prefix
+    #     @modules_prefix ||= begin
+    #       modules = self.name.split('::').slice(0..-2)
+    #       modules.empty? ? '' : "#{modules.join('/')}/"
+    #     end
+    #   end
+
+    #   #
+    #   # Get method name from path
+    #   # Example:
+    #   #   / => :index
+    #   #   /users/:id => :users
+    #   #   /users/:id/addresses => :addresses
+    #   #
+    #   def extract_method_name(path, via)
+    #     return :index if path =~ %r(\A/?#{@_prefix}\z)
+
+    #     parts = path.split('/').reverse!
+
+    #     return parts.find { |part| !part.start_with?(':') } if parts.first != ':id'
+
+    #     case via
+    #     when :get
+    #       :show
+    #     when :post
+    #       :create
+    #     when :put
+    #       :update
+    #     when :delete
+    #       :destroy
+    #     else
+    #       raise "Cannot extract method name from #{path}"
+    #     end
+    #   end
+
+    #   #
+    #   # Creates path with version, namespace and
+    #   # given path, then normalizes it
+    #   #
+    #   def normalize_path(path)
+    #     parts = []
+    #     parts << @_prefix unless !@_prefix || path =~ %r(\A/?#{@_prefix})
+    #     parts << current_namespace.path unless !current_namespace? || path =~ %r(/#{current_namespace.path})
+    #     parts << path.to_s unless path == '/'
+    #     parts.join('/')
+    #   end
+    # end
+
+    ActiveSupport.run_load_hooks(:action_controller, self)
+  end
+end

data/lib/raisin/configuration.rb

@@ -0,0 +1,25 @@
+module Raisin
+  class VersionConfig
+    attr_accessor :vendor
+    attr_writer :using
+
+    def using
+      @using || :header
+    end
+  end
+
+  module Configuration
+    mattr_accessor :enable_auth_by_default
+    @@enable_auth_by_default = false
+
+    mattr_accessor :default_auth_method
+    @@default_auth_method = :authenticate_user! # Devise FTW
+
+    mattr_accessor :response_formats
+    @@response_formats = [:json]
+
+    def self.version
+      @version_config ||= VersionConfig.new
+    end
+  end
+end

data/lib/raisin/endpoint.rb

@@ -0,0 +1,39 @@
+module Raisin
+  class Endpoint
+    include Exposable
+
+    attr_reader :response_body, :auth_method, :formats
+
+    def initialize
+      @response_body  = nil
+      @auth_method    = nil
+      @formats = []
+    end
+
+    def response(&block)
+      @response_body = block
+    end
+
+    def has_response?
+      !!response_body
+    end
+
+    def desc(description)
+      # noop
+    end
+
+    def format(*mime_types)
+      @formats.concat mime_types
+    end
+
+    def enable_auth(method = Configuration.default_auth_method)
+      return if Configuration.enable_auth_by_default
+      @auth_method = method
+    end
+
+    def skip_auth(method = Configuration.default_auth_method)
+      return unless Configuration.enable_auth_by_default
+      @auth_method = method
+    end
+  end
+end

data/lib/raisin/exposable.rb

@@ -0,0 +1,18 @@
+module Raisin
+  module Exposable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :exposure, :lazy_expose
+    end
+
+    def expose(name, &block)
+      @exposure = name
+      @lazy_expose = block
+    end
+
+    def expose?
+      !!@exposure
+    end
+  end
+end

data/lib/raisin/middleware/base.rb

@@ -0,0 +1,13 @@
+module Raisin
+  module Middleware
+    class Base
+      def initialize(app, *args)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/raisin/middleware/header.rb

@@ -0,0 +1,39 @@
+module Raisin
+  module Middleware
+    class Header < Base
+
+      def self.merge(base, other)
+        base_options, other_options = base.pop, other.pop
+        [base.concat(other), base_options.merge!(other_options)]
+      end
+
+      attr_reader :options, :versions
+
+      def initialize(app, versions, options = {})
+        super
+        @options = options
+        @versions = Array(versions)
+      end
+
+      def call(env)
+        @env = env
+        return [406, {}, ["You shall not pass!"]] unless verify_http_accept_header
+        super
+      end
+
+      private
+
+      def verify_http_accept_header
+        header = @env['HTTP_ACCEPT']
+        if (matches = %r{application/vnd\.(?<vendor>[a-z]+)-(?<version>v[0-9]+)\+(?<format>[a-z]+)?}.match(header)) &&
+           (versions.include?(matches[:version]) || versions.include?(Raisin::Router::Version::ALL)) &&
+           (!options.key?(:vendor) || options[:vendor] == matches[:vendor])
+
+          @env['raisin.request.formats'] = [Mime::Type.lookup("application/#{matches[:format]}")]
+          return true
+        end
+        false
+      end
+    end
+  end
+end

data/lib/raisin/mixin.rb

@@ -0,0 +1,53 @@
+module Raisin
+  module Mixin
+    extend ActiveSupport::Concern
+
+    def call
+    end
+
+    module ClassMethods
+      def response(&block)
+        define_method(:call, &block) if block_given?
+      end
+
+      def desc(description)
+        # noop
+      end
+      alias_method :description, :desc
+
+      def format(*args)
+        self.class_eval <<-EOF, __FILE__, __LINE__ + 1
+          respond_to(*#{args})
+        EOF
+      end
+
+      def enable_auth(method = nil)
+        method ||= Configuration.default_auth_method
+        send(:before_filter, method) unless Configuration.enable_auth_by_default
+      end
+
+      def disable_auth(method = nil)
+        method ||= Configuration.default_auth_method
+        send(:skip_before_filter, method) if Configuration.enable_auth_by_default
+      end
+
+      def expose(name, &block)
+        if block_given?
+          define_method(name) do |*args|
+            ivar = "@#{name}"
+
+            if instance_variable_defined?(ivar)
+              instance_variable_get(ivar)
+            else
+              instance_variable_set(ivar, instance_exec(block, *args, &block))
+            end
+          end
+        else
+          attr_reader name
+        end
+
+        helper_method name
+      end
+    end
+  end
+end

data/lib/raisin/namespace.rb

@@ -0,0 +1,25 @@
+module Raisin
+  class Namespace
+    include Exposable
+
+    attr_reader :path, :methods, :filters
+
+    def initialize(path)
+      @path = path
+      @methods = []
+      @filters = {
+        before: [],
+        after:  [],
+        around: []
+      }
+    end
+
+    def add(method)
+      @methods << method
+    end
+
+    def filter(type, *args, &block)
+      @filters[type] << [args.first, block]
+    end
+  end
+end

data/lib/raisin/rails/request.rb

@@ -0,0 +1,9 @@
+module Raisin
+  module ApiFormat
+    def formats
+      @env["action_dispatch.request.formats"] ||= @env['raisin.request.formats'] || super
+    end
+  end
+end
+
+ActionDispatch::Request.send(:include, Raisin::ApiFormat)

data/lib/raisin/rails/routes.rb

@@ -0,0 +1,34 @@
+module ActionDispatch::Routing
+  class Mapper
+
+    #
+    #
+    #
+    def mount_api(raisin_api)
+      raisin_api.routes.each do |method, path, endpoint|
+        send(method, path, to: endpoint) # get '/users', to: 'users#index'
+      end
+    end
+  end
+
+  class RouteSet
+    class Dispatcher
+
+      #
+      # Allow to use controller like 'UsersAPI' instead of 'UsersController'
+      #
+      def controller_reference_with_api(controller_param)
+        controller_name = "#{controller_param.camelize}Api"
+        unless controller = @controllers[controller_param]
+          controller = @controllers[controller_param] =
+            ActiveSupport::Dependencies.reference(controller_name)
+        end
+        controller.get(controller_name)
+      rescue NameError
+        controller_reference_without_api(controller_param)
+      end
+
+      alias_method_chain :controller_reference, :api
+    end
+  end
+end

data/lib/raisin/railtie.rb

@@ -0,0 +1,13 @@
+require 'raisin/rails/routes'
+require 'raisin/rails/request'
+
+module Raisin
+  class Railtie < Rails::Railtie
+
+    # Force routes to be loaded if we are doing any eager load.
+    config.before_eager_load { |app| app.reload_routes! }
+
+    initializer "raisin.initialize" do |app|
+    end
+  end
+end

data/lib/raisin/router.rb

@@ -0,0 +1,90 @@
+module Raisin
+  class Router
+    class Version
+      ALL = 'all'
+
+      attr_reader :version, :type, :options
+
+      def initialize(version, options = {})
+        @version = version.to_s
+        @type = options.delete(:using).try(:to_sym) || Configuration.version.using
+        @options = { vendor: Configuration.version.vendor }.merge!(options)
+
+        validate!
+      end
+
+      private
+
+      def validate!
+        raise 'Missing :using options for version' unless type
+
+        case type
+        when :header
+          raise 'Missing :vendor options when using header versionning' unless options[:vendor]
+        when :path
+          raise ':all cannot be used with path versionning' if version == ALL
+        end
+      end
+    end
+
+    def self.reset
+      @_current_version = nil
+      @_routes = []
+    end
+
+    #
+    # Reset class variables on the subclass when inherited
+    #
+    def self.inherited(subclass)
+      subclass.reset
+    end
+
+    class << self
+      attr_internal_accessor :routes, :current_version
+
+      def mount(api)
+        mount_version_middleware(api) if version?(:header)
+        self.routes.concat(version?(:path) ? pathed_routes(api.routes) : api.routes)
+      end
+
+      #
+      # Set version for current block
+      #
+      def version(version, options = {}, &block)
+        self.current_version = Version.new(version, options)
+        yield
+        self.current_version = nil
+      end
+
+      private
+
+      def mount_version_middleware(api)
+        api.use_or_update Middleware::Header, self.current_version.version, self.current_version.options
+      end
+
+      def version?(type)
+        self.current_version && self.current_version.type == type
+      end
+
+      def pathed_routes(routes)
+        self.routes.map! { |via, path, opts|
+          path.append('/') unless path.start_with?('/')
+          path.append(current_version.version)
+          [via, path, opts]
+        }
+      end
+    end
+
+    # #
+    # # Make the API a rack endpoint
+    # #
+    # def self.call(env)
+    #   @_route_set.freeze unless @_route_set.frozen?
+    #   @_route_set.call(env)
+    # end
+
+    # Mount Raisin::Base into the api
+    #
+
+  end
+end

data/lib/raisin/testing/rspec/api_helper.rb

@@ -0,0 +1,12 @@
+module Raisin
+  module RSpecApiHelper
+    extend ActiveSupport::Concern
+
+    included do
+      include RSpec::Rails::ControllerExampleGroup
+      subject { controller }
+    end
+
+  end
+end
+

data/lib/raisin/testing/rspec/dsl.rb

@@ -0,0 +1,97 @@
+require 'raisin/testing/rspec/unit_helper'
+require 'raisin/testing/rspec/api_helper'
+
+module Raisin
+  module Testing
+    module RSpec
+
+      #
+      #
+      #
+      module HttpMethods
+        %w(get head post put delete).each do |verb|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            def #{verb}(*args)
+              method = self.example.metadata[:current_method].to_s.downcase
+              super(method, *args)
+            end
+          EOF
+        end
+      end
+
+      #
+      #
+      #
+      module DSL
+        %w(get head post put delete).each do |verb|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            def #{verb}(path_or_klass, &block)
+              self.metadata[:current_klass] = _klass_from_path(path_or_klass, :#{verb})
+              self.instance_eval(&block)
+              self.metadata.delete(:current_klass)
+            end
+          EOF
+        end
+
+        def unit(&block)
+          _describe_controller(self.metadata[:current_klass], self, &block).tap do |klass|
+            klass.send(:include, Raisin::RSpecUnitHelper)
+          end
+        end
+
+        def response(format = :json, &block)
+          self.metadata[:type] = :api
+          _describe_controller(self.metadata[:current_klass], self, &block).tap do |klass|
+            klass.send(:include, Raisin::RSpecApiHelper)
+            klass.send(:include, HttpMethods)
+            klass.send(:render_views) if ::Raisin::Configuration.testing_render_views
+            klass.send(:before) {
+              request.accept = format.is_a?(Symbol) ? "application/#{format}" : format
+            }
+          self.metadata.delete(:type)
+          end
+        end
+
+        protected
+
+        def _klass_from_path(path_or_klass, via)
+          api_klass = _find_first_api_klass
+
+          case path_or_klass
+          when String
+            method_name = api_klass.send(:extract_method_name, api_klass.send(:normalize_path, path_or_klass), via)
+            self.metadata[:current_method] = method_name
+            api_klass.const_get(method_name.camelize)
+          when Symbol
+            self.metadata[:current_method] = path_or_klass
+            api_klass.const_get(path_or_klass.to_s.camelize)
+          else
+            path_or_klass
+          end
+        end
+
+        def _find_first_api_klass
+          metadata = self.metadata[:example_group]
+          klass = nil
+
+          until metadata.nil? || klass.respond_to?(:new)
+            klass    = metadata[:description_args].first
+            metadata = metadata[:example_group]
+          end
+
+          klass
+        end
+
+        def _describe_controller(klass, parent, &block)
+          result = parent.describe(klass, &block)
+          result.instance_eval <<-EOF
+            def controller_class
+              #{klass}
+            end
+          EOF
+          result
+        end
+      end
+    end
+  end
+end

data/lib/raisin/testing/rspec/functional_test.rb

@@ -0,0 +1,28 @@
+require 'raisin/testing/rspec/test_request'
+
+module Raisin
+  module FunctionalTest
+    def self.append_features(base)
+      base.class_eval do
+        include RSpec::Rails::ControllerExampleGroup
+        extend ClassMethods
+      end
+
+      super
+    end
+
+    module ClassMethods
+      def controller_class
+        metadata = self.metadata[:example_group]
+        klass    = nil
+
+        until metadata.nil? || klass.respond_to?(:new)
+          klass    = metadata[:description_args].first
+          metadata = metadata[:example_group]
+        end
+
+        klass.respond_to?(:new) ? klass : super
+      end
+    end
+  end
+end

data/lib/raisin/testing/rspec/test_request.rb

@@ -0,0 +1,21 @@
+module ActionController
+  class TestRequest < ActionDispatch::TestRequest
+
+    #
+    # Transforms Raisin controller's path as a standart Rails path
+    # before assigning parameters to the request
+    #
+    # Example:
+    #   controller_path: 'users_api#index', action: 'index'
+    #   becomes
+    #   controller_path: 'users', action: 'index'
+    #
+    def assign_parameters_with_api(routes, controller_path, action, parameters = {})
+      controller_path.sub!(/_api/, '')
+      controller_path.sub!(/\/?#{action}/, '')
+      assign_parameters_without_api(routes, controller_path, action, parameters)
+    end
+
+    alias_method_chain :assign_parameters, :api
+  end
+end

data/lib/raisin/testing/rspec/unit_helper.rb

@@ -0,0 +1,34 @@
+module Raisin
+  module UnitHelper
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def controller_class
+        metadata = self.metadata[:example_group]
+        klass    = nil
+
+        until metadata.nil? || klass.respond_to?(:new)
+          klass    = metadata[:description_args].first
+          metadata = metadata[:example_group]
+        end
+
+        klass.respond_to?(:new) ? klass : super
+      end
+    end
+
+    def controller
+      self.class.controller_class.new.tap do |c|
+        c.request   = request
+        c.response  = response
+      end
+    end
+
+    def request
+      @request ||= ActionDispatch::TestRequest.new
+    end
+
+    def response
+      @response ||= ActionDispatch::TestResponse.new
+    end
+  end
+end

data/lib/raisin/testing/rspec/unit_test.rb

@@ -0,0 +1,21 @@
+require 'raisin/testing/rspec/unit_helper'
+
+module Raisin
+  module UnitTest
+    if defined?(RSpec::Rails)
+      include RSpec::Rails::RailsExampleGroup
+      include RSpec::Rails::Matchers::RedirectTo
+      include RSpec::Rails::Matchers::RenderTemplate
+    end
+
+    def self.append_features(base)
+      base.class_eval do
+        include Raisin::UnitHelper
+        subject { controller }
+      end
+
+      super
+    end
+
+  end
+end

data/lib/raisin/testing/rspec.rb

@@ -0,0 +1,10 @@
+# require 'rspec'
+# require 'raisin/testing/rspec/dsl'
+require 'raisin/testing/rspec/unit_test'
+require 'raisin/testing/rspec/functional_test'
+
+# require 'raisin/testing/rspec/helper'
+
+# RSpec.configure do |c|
+#   c.extend(Raisin::Testing::RSpec::DSL)
+# end

data/lib/raisin/version.rb

@@ -0,0 +1,3 @@
+module Raisin
+  VERSION = "0.0.1"
+end

data/lib/raisin.rb

@@ -0,0 +1,22 @@
+require 'raisin/version'
+
+require 'raisin/middleware/base'
+require 'raisin/middleware/header'
+
+require 'raisin/configuration'
+
+require 'raisin/exposable'
+require 'raisin/namespace'
+require 'raisin/mixin'
+
+require 'raisin/router'
+require 'raisin/base'
+require 'raisin/api'
+
+module Raisin
+  def self.configure
+    yield Configuration if block_given?
+  end
+end
+
+require 'raisin/railtie'

data/raisin.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'raisin/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "raisin"
+  gem.version       = Raisin::VERSION
+  gem.authors       = ["ccocchi"]
+  gem.email         = ["cocchi.c@gmail.com"]
+  gem.description   = %q{An opiniated micro-framework to easily build elegant API on top of Rails}
+  gem.summary       = %q{An opiniated micro-framework to easily build elegant API on top of Rails}
+  gem.homepage      = "https://github.com/ccocchi/raisin"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: raisin
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ccocchi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-13 00:00:00.000000000 Z
+dependencies: []
+description: An opiniated micro-framework to easily build elegant API on top of Rails
+email:
+- cocchi.c@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/raisin.rb
+- lib/raisin/api.rb
+- lib/raisin/base.rb
+- lib/raisin/configuration.rb
+- lib/raisin/endpoint.rb
+- lib/raisin/exposable.rb
+- lib/raisin/middleware/base.rb
+- lib/raisin/middleware/header.rb
+- lib/raisin/mixin.rb
+- lib/raisin/namespace.rb
+- lib/raisin/rails/request.rb
+- lib/raisin/rails/routes.rb
+- lib/raisin/railtie.rb
+- lib/raisin/router.rb
+- lib/raisin/testing/rspec.rb
+- lib/raisin/testing/rspec/api_helper.rb
+- lib/raisin/testing/rspec/dsl.rb
+- lib/raisin/testing/rspec/functional_test.rb
+- lib/raisin/testing/rspec/test_request.rb
+- lib/raisin/testing/rspec/unit_helper.rb
+- lib/raisin/testing/rspec/unit_test.rb
+- lib/raisin/version.rb
+- raisin.gemspec
+homepage: https://github.com/ccocchi/raisin
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: An opiniated micro-framework to easily build elegant API on top of Rails
+test_files: []