raisin 0.0.2 → 0.0.4

data/README.md

@@ -150,6 +150,14 @@ Raisin.configure do |c|
 end
 ```
 
+If you are using versionning via header, you also need to add a middleware to your application stack
+
+```ruby
+#config/application.rb
+
+config.middleware.use Raisin::Middleware
+```
+
 ## Contributing
 
 1. Fork it

data/lib/raisin/api/dsl.rb

@@ -0,0 +1,177 @@
+module Raisin
+  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)
+          
+          if current_namespace && current_namespace.expose?
+            current_namespace.exposures.each do |name, b|
+              klass.send(:expose, name, &b)
+            end
+          end
+
+          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
+end

data/lib/raisin/api.rb

@@ -1,26 +1,22 @@
-module Raisin
-  class MiddlewareStack < ActionDispatch::MiddlewareStack
-    class Middleware < ActionDispatch::MiddlewareStack::Middleware
-      def update(args)
-        @args = args
-      end
-    end
-  end
+require 'raisin/api/dsl'
 
+module Raisin
   class API
-    cattr_accessor :middleware_stack
-    @@middleware_stack = Raisin::MiddlewareStack.new
 
+    #
+    # Returns a proc representing our action to be called in the given
+    # environment.
+    #
     def self.action(name, klass = ActionDispatch::Request)
-      middleware_stack.build 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)
+      ->(env) { self.const_get(name.camelize).new.dispatch(:call, klass.new(env)) }
     end
 
+    #
+    # The abstract class that is inherited by all actions.
+    #
+    # It includes actions DSL, default call method, global authentication
+    # filter and global respond_to
+    #
     def self.action_klass
       @_klass ||= begin
         klass = Class.new(::Raisin::Base)
@@ -35,10 +31,14 @@ module Raisin
       end
     end
 
-    def self.action_klass=(klass)
+    def self.action_klass=(klass) # :nodoc:
       @_klass = klass
     end
 
+    #
+    # Resets routes and namespaces.
+    # Sets default prefix to api_name (e.g PostsAPI => 'api')
+    #
     def self.reset
       @_routes = []
       @_prefix = self.api_name
@@ -46,202 +46,29 @@ module Raisin
       @_single_resource = false
     end
 
+    #
+    # Resets routes and namespaces for each new API class.
+    # The action class is copied for some reasons (??)
+    #
     def self.inherited(subclass)
       super
       subclass.reset
-      subclass.middleware_stack = self.middleware_stack.dup
       subclass.action_klass = self.action_klass.dup
     end
 
+    #
+    # Returns the last part of the api's name, underscored, without the ending
+    # <tt>API</tt>. For instance, PostsAPI returns <tt>posts</tt>.
+    # Namespaces are left out, so Admin::PostsAPI returns <tt>posts</tt> as well.
+    #
     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
+    def self.routes # :nodoc:
       @_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
-
+    extend Raisin::DSL
   end
 end

data/lib/raisin/base.rb

@@ -1,4 +1,8 @@
 module Raisin
+
+  #
+  # Abstract class for all actions.
+  #
   class Base < ActionController::Metal
     abstract!
 
@@ -15,8 +19,6 @@ module Raisin
       def perform_caching=(*); end
       def helpers_path=(*); end
       def allow_forgery_protection=(*); end
-      # def helper_method(*); end
-      # def helper(*); end
     end
 
     extend Compatibility
@@ -44,17 +46,10 @@ module Raisin
       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
@@ -67,171 +62,12 @@ module Raisin
     end
 
     #
-    # `call` is the only method to be processed. #process is not
-    # called in the normal process only in tests
+    # In test env, action is not :call. This is a bit of a hack
     #
     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/exposable.rb

@@ -3,16 +3,19 @@ module Raisin
     extend ActiveSupport::Concern
 
     included do
-      attr_reader :exposure, :lazy_expose
+      attr_reader :exposures
+    end
+
+    def initialize(*args)
+      @exposures = []
     end
 
     def expose(name, &block)
-      @exposure = name
-      @lazy_expose = block
+      @exposures << [name, block]
     end
 
     def expose?
-      !!@exposure
+      !exposures.empty?
     end
   end
 end

data/lib/raisin/middleware.rb

@@ -0,0 +1,31 @@
+module Raisin
+  class Middleware
+    ACCEPT_REGEXP = /application\/vnd\.(?<vendor>[a-z]+)-(?<version>v[0-9]+)\+(?<format>[a-z]+)?/
+
+    def initialize(app)
+      @app = app
+      @vendor = Configuration.version.vendor
+    end
+
+    def call(env)
+      @env = env
+      if verify_accept_header
+        @app.call(@env)
+      else
+        [406, {}, []]
+      end
+    end
+
+    private
+
+    def verify_accept_header
+      if (matches = ACCEPT_REGEXP.match(@env['HTTP_ACCEPT'])) && @vendor == matches[:vendor]
+        @env['raisin.version']  = matches[:version]
+        @env['raisin.format']   = "application/#{matches[:format]}"
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/raisin/namespace.rb

@@ -5,6 +5,8 @@ module Raisin
     attr_reader :path, :methods, :filters
 
     def initialize(path)
+      super
+
       @path = path
       @methods = []
       @filters = {

data/lib/raisin/rails/request.rb

@@ -1,7 +1,18 @@
 module Raisin
   module ApiFormat
     def formats
-      @env["action_dispatch.request.formats"] ||= @env['raisin.request.formats'] || super
+      @env["action_dispatch.request.formats"] ||= 
+        if @env.key?('raisin.format')
+          Array(Mime::Type.lookup(@env['raisin.format']))
+        elsif parameters[:format]
+          Array(Mime[parameters[:format]])
+        elsif use_accept_header && valid_accept_header
+          accepts
+        elsif xhr?
+          [Mime::JS]
+        else
+          [Mime::HTML]
+        end
     end
   end
 end

data/lib/raisin/rails/routes.rb

@@ -1,3 +1,5 @@
+require 'raisin/version_constraint'
+
 module ActionDispatch::Routing
   class Mapper
 
@@ -5,8 +7,14 @@ module ActionDispatch::Routing
     #
     #
     def mount_api(raisin_api)
-      raisin_api.routes.each do |method, path, endpoint|
-        send(method, path, to: endpoint) # get '/users', to: 'users#index'
+      raisin_api.versions.each do |version, routes|
+        next if routes.empty?
+
+        send(:constraints, Raisin::VersionConstraint.new(version)) {
+          routes.each do |method, path, endpoint|
+            send(method, path, to: endpoint)
+          end
+        }
       end
     end
   end

data/lib/raisin/railtie.rb

@@ -6,8 +6,5 @@ module Raisin
 
     # 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

@@ -1,36 +1,6 @@
 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
+    ALL_VERSIONS = :all
 
     #
     # Reset class variables on the subclass when inherited
@@ -39,31 +9,37 @@ module Raisin
       subclass.reset
     end
 
+    def self.reset
+      @_current_version = nil
+      @_versions = { ALL_VERSIONS => [] }
+    end
+
     class << self
-      attr_internal_accessor :routes, :current_version
+      attr_internal_accessor :versions, :current_version
 
       def mount(api)
-        mount_version_middleware(api) if version?(:header)
-        self.routes.concat(version?(:path) ? pathed_routes(api.routes) : api.routes)
+        if version?(:header)
+          @_versions[self.current_version].concat(api.routes)
+        else
+          @_versions[ALL_VERSIONS].concat(version?(:path) ? pathed_routes(api.routes) : api.routes)
+        end
       end
 
       #
       # Set version for current block
       #
       def version(version, options = {}, &block)
-        self.current_version = Version.new(version, options)
+        version = version.to_s
+        self.current_version = version
+        @_versions[version] = [] if version?(:header)
         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
+        self.current_version && Configuration.version.using == type
       end
 
       def pathed_routes(routes)
@@ -75,16 +51,5 @@ module Raisin
       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/version.rb

@@ -1,3 +1,3 @@
 module Raisin
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/raisin/version_constraint.rb

@@ -0,0 +1,12 @@
+module Raisin
+  class VersionConstraint
+    def initialize(version)
+      @version  = version
+      @bypass   = version == Router::ALL_VERSIONS
+    end
+
+    def matches?(req)
+      @bypass || @version == req.env['raisin.version']
+    end
+  end
+end

data/lib/raisin.rb

@@ -1,8 +1,5 @@
 require 'raisin/version'
 
-require 'raisin/middleware/base'
-require 'raisin/middleware/header'
-
 require 'raisin/configuration'
 
 require 'raisin/exposable'
@@ -13,6 +10,9 @@ require 'raisin/router'
 require 'raisin/base'
 require 'raisin/api'
 
+require 'raisin/middleware'
+require 'raisin/version_constraint'
+
 module Raisin
   def self.configure
     yield Configuration if block_given?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raisin
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-04 00:00:00.000000000 Z
+date: 2012-12-20 00:00:00.000000000 Z
 dependencies: []
 description: An opiniated micro-framework to easily build elegant API on top of Rails
 email:
@@ -25,12 +25,12 @@ files:
 - Rakefile
 - lib/raisin.rb
 - lib/raisin/api.rb
+- lib/raisin/api/dsl.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/middleware.rb
 - lib/raisin/mixin.rb
 - lib/raisin/namespace.rb
 - lib/raisin/rails/request.rb
@@ -45,6 +45,7 @@ files:
 - lib/raisin/testing/rspec/unit_helper.rb
 - lib/raisin/testing/rspec/unit_test.rb
 - lib/raisin/version.rb
+- lib/raisin/version_constraint.rb
 - raisin.gemspec
 homepage: https://github.com/ccocchi/raisin
 licenses: []

data/lib/raisin/middleware/base.rb

@@ -1,13 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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