Remountable APIs, allows to re-mount APIs that inherit from this

Creates a new module that can replace a Grape::API in most cases which allows APIs to be re-mounted

Author: myxoh

lib/grape.rb

@@ -29,6 +29,7 @@ module Grape
 
   eager_autoload do
     autoload :API
+    autoload :RemountableAPI
     autoload :Endpoint
 
     autoload :Namespace

lib/grape/dsl/routing.rb

@@ -77,9 +77,12 @@ def do_not_route_options!
           namespace_inheritable(:do_not_route_options, true)
         end
 
-        def mount(mounts)
+        def mount(mounts, with: {})
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|
+            if app.is_a?(Class) && app.ancestors.include?(Grape::RemountableAPI)
+              return mount(app.new_instance(configuration: with) => path)
+            end
             in_setting = inheritable_setting
 
             if app.respond_to?(:inheritable_setting, true)

lib/grape/remountable_api.rb

@@ -0,0 +1,64 @@
+module Grape
+  # The RemountableAPI class can replace most API classes, except for the base one that is to be mounted in rack.
+  # should subclass this class in order to build an API.
+  class RemountableAPI
+    class << self
+      # When inherited, will create a list of all instances (times the API was mounted)
+      # It will listen to the setup required to mount that endpoint, and replicate it on any new instance
+      def inherited(remountable_class)
+        remountable_class.instance_variable_set(:@instances, [])
+        remountable_class.instance_variable_set(:@setup, [])
+
+        base_instance = Class.new(Grape::API)
+        base_instance.define_singleton_method(:configuration) { {} }
+
+        remountable_class.instance_variable_set(:@base_instance, base_instance)
+        base_instance.constants.each do |constant_name|
+          remountable_class.const_set(constant_name, base_instance.const_get(constant_name))
+        end
+      end
+
+      # The remountable class can have a configuration hash to provide some dynamic class-level variables.
+      # For instance, a descripcion could be done using: `desc configuration[:description]` if it may vary
+      # depending on where the endpoint is mounted. Use with care, if you find yourself using configuration
+      # too much, you may actually want to provide a new API rather than remount it.
+      def new_instance(configuration: {})
+        instance = Class.new(Grape::API)
+        instance.instance_variable_set(:@configuration, configuration)
+        instance.define_singleton_method(:configuration) { @configuration }
+        replay_setup_on(instance)
+        @instances << instance
+        instance
+      end
+
+      # Replays the set up to produce an API as defined in this class, can be called
+      # on classes that inherit from Grape::API
+      def replay_setup_on(instance)
+        @setup.each do |setup_stage|
+          instance.send(setup_stage[:method], *setup_stage[:args], &setup_stage[:block])
+        end
+      end
+
+      private
+
+      # Adds a new stage to the set up require to get a Grape::API up and running
+      def add_setup(method, *args, &block)
+        setup_stage = { method: method, args: args, block: block }
+        @setup << setup_stage
+        @base_instance.send(setup_stage[:method], *setup_stage[:args], &setup_stage[:block])
+      end
+
+      def method_missing(method, *args, &block)
+        if respond_to_missing?(method, true)
+          add_setup(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @base_instance.respond_to?(name, include_private)
+      end
+    end
+  end
+end

spec/grape/remountable_api_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'shared/versioning_examples'
+
+describe Grape::RemountableAPI do
+  subject(:a_remountable_api) { Class.new(Grape::RemountableAPI) }
+  let(:root_api) { Class.new(Grape::API) }
+
+  def app
+    root_api
+  end
+
+  describe 'mounted RemountableAPI' do
+    context 'with a defined route' do
+      before do
+        a_remountable_api.get '/votes' do
+          '10 votes'
+        end
+      end
+
+      context 'when mounting one instance' do
+        before do
+          root_api.mount a_remountable_api
+        end
+
+        it 'can access the endpoint' do
+          get '/votes'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+
+      context 'when mounting twice' do
+        before do
+          root_api.mount a_remountable_api => '/posts'
+          root_api.mount a_remountable_api => '/comments'
+        end
+
+        it 'can access the votes in both places' do
+          get '/posts/votes'
+          expect(last_response.body).to eql '10 votes'
+          get '/comments/votes'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+
+      context 'when mounting on namespace' do
+        before do
+          stub_const('StaticRefToAPI', a_remountable_api)
+          root_api.namespace 'posts' do
+            mount StaticRefToAPI
+          end
+
+          root_api.namespace 'comments' do
+            mount StaticRefToAPI
+          end
+        end
+
+        it 'can access the votes in both places' do
+          get '/posts/votes'
+          expect(last_response.body).to eql '10 votes'
+          get '/comments/votes'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+    end
+
+    context 'with a dynamically configured route' do
+      before do
+        a_remountable_api.namespace 'api' do
+          get "/#{configuration[:path]}" do
+            '10 votes'
+          end
+        end
+        root_api.mount a_remountable_api, with: { path: 'votes' }
+        root_api.mount a_remountable_api, with: { path: 'scores' }
+      end
+
+      it 'will use the dynamic configuration on all routes' do
+        get 'api/votes'
+        expect(last_response.body).to eql '10 votes'
+        get 'api/scores'
+        expect(last_response.body).to eql '10 votes'
+      end
+    end
+  end
+end