grape-reload 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d23fb6507e6ffdadf978ae7cafa32ad6a49b7b09
-  data.tar.gz: 4cdb689e50c6f760afb8ea2fe660b3c4d3971cea
+  metadata.gz: cf764d2710409ccf448fb1a9b1878611ae510b28
+  data.tar.gz: 74bb786cd48bd89ac78e95e955680bb695e30846
 SHA512:
-  metadata.gz: ee472baaa8f3a405e193940073a8ea0734501179432b18f33e6d625e58728d06cf884e318430581f720c6d2598d7ea5811b089a1fc5e650a62fef5d79fa5e846
-  data.tar.gz: e6d6ce030ee2f4f6aff852817276cb3597fb852cbf0c178505a069b622aa5cbf662049450e20e356cb66555288817d1be149d5b618da21fe586a87a647172b60
+  metadata.gz: 9b918ce662a102851066936b2bb1c3a534af0dfbee84a900e0692f80095ef67905bdf47c8c7773c26619a6b64c8e826403bad8bfe184734cde1c8c035fc96b36
+  data.tar.gz: 21a8509583dc86cb23b3747536c32090fb88deeb415bb44ff277797193a95f6368d181ae51865e43d9f96fb4a72d4d92766cb6ca82e83ef2caf93844983d4291

data/README.md

@@ -23,21 +23,22 @@ Or install it yourself as:
 
 In your config.ru you use Grape::RackBuilder to mount your apps:
 
-    builder = Grape::RackBuilder.setup do
+    Grape::RackBuilder.setup do
         logger Logger.new(STDOUT)
         add_source_path File.expand_path('**/*.rb', YOUR_APP_ROOT)
         reload_threshold 1 # Reload sources not often one second
+        force_reloading true # Force reloading for any environment (not just dev), useful for testing
         mount 'Your::App', to: '/'
         mount 'Your::App1', to: '/app1'
     end
 
-    run builder.boot!.application
+    run Grape::RackBuilder.boot!.application
 
-Grape::Reload will resolve all class dependencies and load your files in appropriate order, so you don't need to include 'require' or 'require_relative' for your app classes.
+Grape::Reload will resolve all class dependencies and load your files in appropriate order, so you don't need to include 'require' or 'require_relative' in your sources.
 
 ## Restrictions:
-
-If you want to monkey-patch class in your code for any reason, you should use 
+### Monkey patching
+If you want to monkey-patch class in code, you want to be reloaded, for any reason, you should use
     
     AlreadyDefined.class_eval do 
     end
@@ -45,18 +46,53 @@ If you want to monkey-patch class in your code for any reason, you should use
 instead of
 
     class AlreadyDefined
-    end  
+    end
 
 because it confuses dependency resolver
 
+### Full-qualified const name usage
+Consider code
+
+    require 'some_file' # (declares SomeModule::SomeClass)
+
+    here_is_your_code(SomeClass)
+
+Ruby will resolve SomeClass to SomeModule::SomeClass in runtime.
+Dependency resolver will display an error, because it expects you to
+use full-qualified class name in this situation.
+Anyway, it would not raise exception anymore (since e5b58f4)
+
+    here_is_your_code(SomeModule::SomeClass)
+
+### Other restrictions
+
+Avoid declaring constants as follows
+
+    class AlreadyDeclaredModule::MyClass
+    end
+
+use
+
+    module AlreadyDeclaredModule
+        class MyClass
+        end
+    end
+
+instead
+
 ## Known issues
 
 * It still lacks of good design :(  
 * MOAR TESTS!!!!111
 
+## TODO
+
+* example Grape application with Grape::Reload
+* Spork integration example
+
 ## Contributing
 
-1. Fork it ( https://github.com/AMar4enko/grape-reload/fork )
+1. Fork it ( https://github.com/AlexYankee/grape-reload/fork )
 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`)

data/lib/grape/reload/dependency_map.rb

@@ -117,7 +117,7 @@ module Grape
           filenames.each {|filename| Grape::RackBuilder.logger.error("Unresolved const reference #{klass} from: #{filename}".colorize(:red)) }
         end
 
-        raise UnresolvedDependenciesError if unresolved_classes.any?
+        Grape::RackBuilder.logger.error("One or more unresolved dependencies found".colorize(:red)) if unresolved_classes.any?
       end
     end
 

data/lib/grape/reload/grape_api.rb

@@ -36,47 +36,68 @@ end
 module Grape
   module Reload
     module AutoreloadInterceptor
-      [:set, :nest, :route, :imbue, :mount, :desc, :params, :helpers, :format, :formatter, :parser, :error_formatter, :content_type].each do |method|
-        eval <<METHOD
-        def #{method}(*args, &block)
-          class_declaration << [:#{method},args,block]
+      extend ActiveSupport::Concern
+
+      def add_head_not_allowed_methods_and_options_methods(*args, &block)
+        self.class.skip_declaration = true
+        super(*args, &block)
+        self.class.skip_declaration = false
+      end
+
+      module ClassMethods
+        attr_accessor :skip_declaration
+
+        def namespace(*args, &block)
+          @skip_declaration = true
+          class_declaration << [:namespace,args,block]
           super(*args, &block)
+          @skip_declaration = false
         end
+
+        [:set, :imbue, :mount, :route, :desc, :params, :helpers, :format, :formatter, :parser, :error_formatter, :content_type].each do |method|
+          eval <<METHOD
+          def #{method}(*args, &block)
+            class_declaration << [:#{method},args,block] unless @skip_declaration
+            super(*args, &block)
+          end
 METHOD
-      end
+        end
 
-      def reinit!
-        declaration = class_declaration.dup
-        @class_decl = []
-        endpoints.each { |e| e.options[:app].reinit! if e.options[:app] }
-        reset!
-        declaration.each {|decl|
-          send(decl[0],*deep_reconstantize.call(decl[1]),&decl[2])
-        }
-        change!
-      end
+        def reinit!
+          declaration = class_declaration.dup
+          @class_decl = []
+          endpoints_cache = endpoints
+          reset!
+          endpoints_cache.each { |e| e.options[:app].reinit! if e.options[:app].respond_to?('reinit!') }
 
-      def recursive_!
+          declaration.each {|decl|
+            send(decl[0],*deep_reconstantize.call(decl[1]),&decl[2])
+          }
+          change!
+        end
 
-      end
-    private
-      def class_declaration
-        @class_decl ||= []
-      end
-      def deep_reconstantize
-        proc = ->(value) {
-          case value
-            when Hash
-              Hash[value.each_pair.map { |k,v| [proc.call(k), proc.call(v)] }]
-            when Array
-              value.map { |v| proc.call(v) }
-            when Class
-              return if value.to_s[0,2] == '#<'
-              value.to_s.constantize
-            else
-              value
-          end
-        }
+        def recursive_!
+
+        end
+      private
+        def class_declaration
+          @class_decl ||= []
+        end
+        def deep_reconstantize
+          proc = ->(value) {
+            case value
+              when Hash
+                Hash[value.each_pair.map { |k,v| [proc.call(k), proc.call(v)] }]
+              when Array
+                value.map { |v| proc.call(v) }
+              when Class
+                return value if value.to_s[0,2] == '#<'
+                value.to_s.constantize
+              else
+                value
+            end
+          }
+        end
       end
     end
   end
@@ -87,7 +108,7 @@ Grape::API.singleton_class.class_eval do
   alias_method :settings_shadowed, :settings
   def inherited(*args)
     inherited_shadowed(*args)
-    args.first.singleton_class.class_eval do
+    args.first.class_eval do
       include Grape::Reload::AutoreloadInterceptor
     end
   end

data/lib/grape/reload/rack.rb

@@ -0,0 +1,7 @@
+module Rack
+  class Cascade
+    def reinit!
+      @apps.map{|app| app.reinit! if app.respond_to?('reinit!') }
+    end
+  end
+end

data/lib/grape/reload/rack_builder.rb

@@ -26,9 +26,9 @@ module Grape
     end
 
     class Config
-      attr_accessor :mounts, :sources, :options
+      attr_accessor :mounts, :sources, :options, :force_reloading
 
-      {environment: RACK_ENV, reload_threshold: 1, logger: LoggingStub}.each_pair do |attr, default|
+      {environment: RACK_ENV, reload_threshold: 1, logger: LoggingStub, force_reloading: false}.each_pair do |attr, default|
         attr_accessor attr
         define_method(attr) { |value = nil|
           @options ||= {}
@@ -41,6 +41,10 @@ module Grape
         (@sources ||= []) << glob
       end
 
+      def use(*args, &block)
+        middleware << [args, block]
+      end
+
       def mount(app_class, options)
         mounts << MountConfig.new(
             app_class: app_class,
@@ -52,6 +56,10 @@ module Grape
       def mounts
         @mounts ||= []
       end
+
+      def middleware
+        @middleware ||= []
+      end
     end
 
     module ClassMethods
@@ -61,6 +69,7 @@ module Grape
       end
 
       def boot!
+        @rack_app = nil
         Grape::Reload::Watcher.setup(sources: Grape::Reload::Sources.new(config.sources))
         self
       end
@@ -68,11 +77,17 @@ module Grape
       def application
         return @rack_app if @rack_app
         mounts = config.mounts
+        middleware = config.middleware
+        force_reloading = config.force_reloading
         environment = config.environment
         reload_threshold = config.reload_threshold
         @rack_app = ::Rack::Builder.new do
+          middleware.each do |parameters|
+            parameters.length == 1 ? use(*parameters.first) : use(*parameters.first, &parameters.last)
+          end
+
           mounts.each_with_index do |m|
-            if environment == 'development'
+            if (environment == 'development') || force_reloading
               r = Rack::Builder.new
               r.use Grape::ReloadMiddleware[reload_threshold]
               r.run m.app_class

data/lib/grape/reload/version.rb

@@ -1,5 +1,5 @@
 module Grape
   module Reload
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/lib/grape/reload/watcher.rb

@@ -17,7 +17,7 @@ module Grape
           return unless options[:force] || file_changed?(file)
 
           Storage.prepare(file) # might call #safe_load recursively
-          logger.debug((file_new?(file) ? "loading" : "reloading") + "#{file}" )
+          logger.debug((file_new?(file) ? "loading" : "reloading") + " #{file}" )
           begin
             with_silence{ require(file) }
             Storage.commit(file)
@@ -102,9 +102,8 @@ module Grape
             changed_files_sorted.each{|f| safe_load(f)}
           end
           changed_files_sorted.map{|f| @sources.dependent_classes(f) }.flatten.uniq.each {|class_name|
-            if (klass = class_name.constantize) < Grape::API
-              klass.reinit!
-            end
+            next unless (klass = class_name.constantize).kind_of? Class
+            klass.reinit! if klass.respond_to?('reinit!')
           }
         end
 

data/lib/grape/reload.rb

@@ -2,3 +2,4 @@ require "grape/reload/version"
 require 'core_ext/string/colorize'
 require 'core_ext/object_space'
 require "grape/reload/rack_builder"
+require "grape/reload/rack"

data/lib/ripper/extract_constants.rb

@@ -53,7 +53,7 @@ class TraversingResult
         end
 
         variants << [ const_ary ]
-        @used << variants.map{|v| v.join('::')}
+        @used << (variants.map{|v| v.join('::')} << '::' + const)
       end
     else
       @used << const
@@ -107,7 +107,7 @@ class TraversingResult
       used = used.map {|variants| variants.map{|v| (v.start_with?('::') ? '' : (namespace || '') + '::') + v }}
     end
 
-    result[:used] = result[:used].concat(used)
+    result[:used] = result[:used].concat(used).uniq
 
     result
   end
@@ -135,7 +135,7 @@ class ASTEntity
         else
           # Code position for identifier
           return if node_ary.kind_of?(Array) and (node_ary.size == 2) and node_ary[0].kind_of?(Integer) and node_ary[1].kind_of?(Integer)
-          node_ary.map{|n| load(n) }
+          node_ary.map{|n| node_for(n) }
         end
       end
     end
@@ -157,7 +157,7 @@ class ASTEntity
         when ASTEntity
           e.collect_constants(result, context || (TraversingContext.new)) unless e.nil?
         when Array
-          e.map{|e| e.collect_constants(result, context || (TraversingContext.new)) unless e.nil? }
+          e.flatten.map{|e| e.collect_constants(result, context || (TraversingContext.new)) unless e.nil? }
         else
       end
     } unless @body.nil?
@@ -172,6 +172,27 @@ class ASTProgramDecl < ASTEntity
   end
 end
 
+class ASTDef < ASTEntity
+  def self.ripper_id; :def end
+  def collect_constants(result, context)
+    result
+  end
+end
+
+class ASTCommand < ASTEntity
+  def self.ripper_id; :command end
+  def initialize(*args)
+    @command = args.first[1]
+    super(*args)
+  end
+  def collect_constants(result, context)
+    @old_stop_collect_constants = context[:stop_collect_constants]
+    context[:stop_collect_constants] = nil unless %w{desc mount params}.index(@command).nil?
+    ret = super(result, context)
+    context[:stop_collect_constants] = @old_stop_collect_constants
+    ret
+  end
+end
 
 class ASTBody < ASTEntity
   def self.ripper_id; :bodystmt end
@@ -207,8 +228,9 @@ class ASTTopConstRef < ASTEntity
   def self.ripper_id; :top_const_ref end
   def collect_constants(result, context)
     context[:top] = true
-    super(result, context)
+    ret = super(result, context)
     context[:top] = false
+    ret
   end
 end
 
@@ -239,6 +261,7 @@ class ASTConst < ASTEntity
     @const_name = args[0]
   end
   def collect_constants(result, context)
+    return super(result, context)  if context[:stop_collect_constants]
     if context[:variable_assignment]
       result.declare_const(@const_name)
     else
@@ -262,7 +285,8 @@ class ASTConstPathRef < ASTEntity
     @const = ASTEntity.node_for(args.last)
   end
   def collect_constants(result, context)
-    if context[:const_path_ref]
+    return super(result, context) if context[:stop_collect_constants]
+    if context[:const_path_ref] || context[:method_add_arg]
       r = TraversingResult.new
       c = context.dup
       c[:analyze_const] = false
@@ -280,6 +304,48 @@ class ASTConstPathRef < ASTEntity
   end
 end
 
+class ASTMethodAddArg < ASTEntity
+  def self.ripper_id; :method_add_arg end
+  def initialize(*args)
+    @path = ASTEntity.node_for(args.first)
+  end
+
+  def collect_constants(result, context)
+    return super(result, context) if context[:stop_collect_constants]
+    if context[:method_add_arg]
+      r = TraversingResult.new
+      c = context.dup
+      c[:analyze_const] = false
+      path_consts = @path.collect_constants(r, context)
+      result.use_const(path_consts.used.join('::'), false)
+    else
+      r = TraversingResult.new
+      new_context = TraversingContext.new([], {method_add_arg: true, analyze_const: false})
+      path_consts = @path.collect_constants(r, new_context)
+      result.use_const(path_consts.used.join('::'))
+    end
+    result
+  end
+end
+
+class ASTDefs < ASTEntity
+  def self.ripper_id; :defs end
+  def collect_constants(result, context)
+    result
+  end
+end
+
+class ASTMethodAddBlock < ASTEntity
+  def self.ripper_id; :method_add_block end
+
+  def collect_constants(result, context)
+    context[:stop_collect_constants] = true
+    ret = super(result, context)
+    context[:stop_collect_constants] = nil
+    ret
+  end
+end
+
 class ASTModule < ASTEntity
   def self.ripper_id; :module end
   def initialize(*args)
@@ -300,8 +366,9 @@ class ASTVarField < ASTEntity
   def self.ripper_id; :var_field end
   def collect_constants(result, context)
     context[:variable_assignment] = true
-    super(result, context)
+    ret = super(result, context)
     context[:variable_assignment] = false
+    ret
   end
 end
 
@@ -313,6 +380,12 @@ class ASTRef < ASTEntity
   end
 end
 
+class ASTLambda < ASTEntity
+  def self.ripper_id; :lambda end
+  def initialize(*args)
+    super(*(args[0..-2]))
+  end
+end
 
 class Ripper
   def self.extract_constants(code)

data/spec/grape/reload/autoreload_interceptor_spec.rb

@@ -1,10 +1,12 @@
 require 'spec_helper'
 require_relative '../../../lib/grape/reload/grape_api'
 describe Grape::Reload::AutoreloadInterceptor do
-  let(:api_class) {
+  let!(:api_class) {
     nested_class = Class.new(Grape::API) do
-      get :route do
-        'nested route'
+      namespace :nested do
+        get :route do
+          'nested route'
+        end
       end
     end
 
@@ -18,7 +20,7 @@ describe Grape::Reload::AutoreloadInterceptor do
   }
 
   describe '.reinit!' do
-    let(:app) {
+    let!(:app) {
       app = Rack::Builder.new
       app.run api_class
       app
@@ -31,10 +33,16 @@ describe Grape::Reload::AutoreloadInterceptor do
       get '/test_route'
       expect(last_response).to succeed
       expect(last_response.body).to eq('test')
+      get '/nested/nested/route'
+      expect(last_response).to succeed
+      expect(last_response.body).to eq('nested route')
       api_class.reinit!
       get '/test_route'
       expect(last_response).to succeed
       expect(last_response.body).to eq('test')
+      get '/nested/nested/route'
+      expect(last_response).to succeed
+      expect(last_response.body).to eq('nested route')
     end
   end
 end

data/spec/grape/reload/dependency_map_spec.rb

@@ -42,9 +42,4 @@ describe Grape::Reload::DependencyMap do
 
     expect(dm.dependent_classes('file1')).to include('::Class2','::Class3')
   end
-
-  it "raises error if dependencies can't be resolved" do
-    allow(dm).to receive(:map).and_return(wrong_class_map)
-    expect { dm.resolve_dependencies! }.to raise_error(Grape::Reload::UnresolvedDependenciesError)
-  end
 end

data/spec/grape/reload/rack_builder_spec.rb

@@ -11,6 +11,17 @@ describe Grape::RackBuilder do
       end
     end
   }
+  let(:middleware) {
+    Class.new do
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        @app.call(env)
+      end
+    end
+  }
+
 
   before do
     builder.setup do
@@ -37,8 +48,16 @@ describe Grape::RackBuilder do
       end
       expect(config.mounts.size).to eq(2)
     end
+
+    it 'allows to add middleware' do
+      builder.setup do
+        use middleware do
+        end
+      end
+      expect(config.middleware.size).to eq(1)
+    end
   end
-  #
+
   describe '.boot!' do
     before(:each) do
       builder.setup do
@@ -63,6 +82,7 @@ describe Grape::RackBuilder do
   describe '.application' do
     before(:each) do
       builder.setup do
+        use middleware
         mount 'Test::App1', to: '/test1'
         mount 'Test::App2', to: '/test2'
       end
@@ -72,6 +92,8 @@ describe Grape::RackBuilder do
       expect{ @app = builder.application }.not_to raise_error
       expect(@app).to be_an_instance_of(Rack::Builder)
       def @app.get_map; @map end
+      def @app.get_use; @use end
+      expect(@app.get_use.size).to eq(1)
       expect(@app.get_map.keys).to include('/test1','/test2')
     end
   end

data/spec/grape/reload/watcher_spec.rb

@@ -2,8 +2,10 @@ require 'grape'
 require 'spec_helper'
 
 describe Grape::Reload::Watcher do
-  def app; @app end
-  before(:example) do
+  def app
+    @app
+  end
+  before(:each) do
     @app =
         Grape::RackBuilder.setup do
           add_source_path File.expand_path('**.rb', APP_ROOT)
@@ -31,6 +33,35 @@ describe Grape::Reload::Watcher do
     end
   end
 
+  describe 'force_reloading' do
+    before(:each) do
+      @app =
+          Grape::RackBuilder.setup do
+            add_source_path File.expand_path('**.rb', APP_ROOT)
+            add_source_path File.expand_path('**/*.rb', APP_ROOT)
+            environment 'test'
+            force_reloading true
+            reload_threshold 0
+            mount 'Test::App1', to: '/test1'
+            mount 'Test::App2', to: '/test2'
+          end.boot!.application
+    end
+
+    it 'reloads files within any environment with force_reloading options set' do
+      get '/test1/test'
+      expect(last_response).to succeed
+      expect(last_response.body).to eq('test1 response')
+
+      with_changed_fixture 'app1/test1.rb' do
+        get '/test1/test'
+        expect(last_response).to succeed
+        expect(last_response.body).to eq('test1 response changed')
+      end
+    end
+  end
+
+
+
   it 'reloads mounted app file' do
     get '/test1/mounted/test1'
     expect(last_response).to succeed

data/spec/ripper/extract_constants_spec.rb

@@ -60,10 +60,71 @@ CODE
     def use_top_level
       TopLevel.new
     end
+    def self.method
+      SomeModule::ShouldntUse.call
+    end
+  end
+CODE
+  }
+
+  let!(:deeply_nested) {
+    <<CODE
+  module Test
+    module Subtest
+      class App2 < Grape::API
+      end
+    end
   end
 CODE
   }
 
+  # Sequel-related
+  let!(:class_reference_with_call) {
+    <<CODE
+    module Test
+      module Subtest
+        class App2 < Grape::API(:test)
+        end
+      end
+    end
+CODE
+  }
+
+  let!(:grape_desc_args) {
+    <<CODE
+    module Test
+      class App < Grape::API
+        group do
+          desc 'Blablabla',
+            entity: [Test::SomeAnotherEntity]
+          get :test do
+            SomeClass.usage
+            'test2 response'
+          end
+        end
+      end
+    end
+CODE
+  }
+
+  let!(:class_level_call_with_args) {
+    <<CODE
+    module Test
+      class TestClass
+        UseModule::UseClass.call(arg)
+      end
+    end
+CODE
+  }
+
+  let!(:lambda_class_usage) {
+    <<CODE
+    some_method ->(arg) {
+      ModuleName::ClassName.call(arg)
+    }
+CODE
+  }
+
   it 'extract consts from code1 correctly' do
     consts = Ripper.extract_constants(code1)
     expect(consts[:declared].flatten).to include(
@@ -81,11 +142,15 @@ CODE
                 '::Test3::AnotherClass',
                 '::Test::NotExists::Test1',
                 '::SomeExternalClass',
-                '::Superclass',
-                '::SomeClass1',
-                '::SomeClass2'
+                '::Superclass'
             )
 
+    expect(consts[:used].flatten).not_to include(
+                                         '::SomeClass1',
+                                         '::SomeClass2'
+                                     )
+
+
   end
   it 'extract consts from code2 correctly' do
     consts = Ripper.extract_constants(code2)
@@ -98,8 +163,37 @@ CODE
                 '::Test::Mount2',
                 '::Test::Mount10',
                 '::Test::SomeAnotherEntity',
-                '::SomeClass',
-                '::TopLevel'
             )
+
+    expect(consts[:used].flatten).not_to include(
+                                             '::SomeClass',
+                                             '::TopLevel'
+                                         )
+
+  end
+
+  it 'extracts consts used in deeply nested modules up to root namespace' do
+    consts = Ripper.extract_constants(deeply_nested)
+    expect(consts[:used].flatten).to include('::Grape::API')
+  end
+
+  it 'extracts const with call (sequel-related)' do
+    consts = Ripper.extract_constants(class_reference_with_call)
+    expect(consts[:used].flatten).to include('::Grape::API')
+  end
+
+  it 'extracts consts from desc method args' do
+    consts = Ripper.extract_constants(grape_desc_args)
+    expect(consts[:used].flatten).to include('::Test::SomeAnotherEntity')
+  end
+
+  it 'does not mess up class name when class level method called with argument' do
+    consts = Ripper.extract_constants(class_level_call_with_args)
+    expect(consts[:used].flatten).to include('::UseModule::UseClass')
+  end
+
+  it 'does not include classes used in lambdas' do
+    consts = Ripper.extract_constants(lambda_class_usage)
+    expect(consts[:used].flatten).not_to include('::ModuleName::ClassName')
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape-reload
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - AMar4enko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-20 00:00:00.000000000 Z
+date: 2014-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -212,6 +212,7 @@ files:
 - lib/grape/reload.rb
 - lib/grape/reload/dependency_map.rb
 - lib/grape/reload/grape_api.rb
+- lib/grape/reload/rack.rb
 - lib/grape/reload/rack_builder.rb
 - lib/grape/reload/storage.rb
 - lib/grape/reload/version.rb