grape-reload 0.0.2

data/lib/grape/reload/watcher.rb

@@ -0,0 +1,146 @@
+require 'ripper'
+require_relative 'rack_builder'
+require_relative 'storage'
+
+module Grape
+  module Reload
+    module Watcher
+      class << self
+        MTIMES = {}
+        # include Padrino::Reloader
+        attr_reader :sources
+        def rack_builder; Grape::RackBuilder end
+
+        def logger; Grape::RackBuilder.logger end
+
+        def safe_load(file, options={})
+          began_at = Time.now
+          return unless options[:force] || file_changed?(file)
+          # return require(file) if feature_excluded?(file)
+
+          Storage.prepare(file) # might call #safe_load recursively
+          logger.devel((file_new?(file) ? "loading" : "reloading") + "#{file}" )
+          begin
+            with_silence{ require(file) }
+            Storage.commit(file)
+            update_modification_time(file)
+          rescue Exception => exception
+            unless options[:cyclic]
+              logger.exception exception, :short
+              logger.error "Failed to load #{file}; removing partially defined constants"
+            end
+            Storage.rollback(file)
+            raise
+          end
+        end
+
+        ##
+        # Tells if a feature should be excluded from Reloader tracking.
+        #
+        def remove_feature(file)
+          $LOADED_FEATURES.delete(file) unless feature_excluded?(file)
+        end
+
+        ##
+        # Tells if a feature should be excluded from Reloader tracking.
+        #
+        def feature_excluded?(file)
+          @sources.file_excluded?(file)
+        end
+
+        def constant_excluded?(const)
+          @sources.class_file(const).nil?
+        end
+
+        def files_for_rotation
+          files = Set.new
+          files += @sources.sorted_files.map{|p| Dir[p]}.flatten.uniq
+        end
+
+        def setup(options)
+          @sources = options[:sources]
+          load_files!
+        end
+
+        ###
+        # Macro for mtime update.
+        #
+        def update_modification_time(file)
+          MTIMES[file] = File.mtime(file)
+        end
+
+
+        def clear
+          MTIMES.each_key{|f| Storage.remove(f)}
+          MTIMES.clear
+        end
+
+        def load_files!
+          files_to_load = files_for_rotation.to_a
+          tries = {}
+          while files_to_load.any?
+            f = files_to_load.shift
+            tries[f] = 1 unless tries[f]
+            begin
+              safe_load(f, cyclic: true, force: true)
+            rescue
+              logger.error $!
+              tries[f] += 1
+              if tries[f] < 3
+                files_to_load << f
+              else
+                raise
+              end
+            end
+          end
+        end
+
+        def reload!
+          files = @sources.fs_changes{|file|
+            File.mtime(file) > MTIMES[file]
+          }
+          changed_files_sorted = @sources.sorted_files.select{|f| files[:changed].include?(f)}
+          @sources.files_reloading do
+            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
+          }
+        end
+
+        ##
+        # Removes the specified class and constant.
+        #
+        def remove_constant(const)
+          return if constant_excluded?(const)
+          base, _, object = const.to_s.rpartition('::')
+          base = base.empty? ? Object : base.constantize
+          base.send :remove_const, object
+          logger.devel "Removed constant #{const} from #{base}"
+        rescue NameError
+        end
+
+        ###
+        # Returns true if the file is new or it's modification time changed.
+        #
+        def file_changed?(file)
+          file_new?(file) || File.mtime(file) > MTIMES[file]
+        end
+
+        def file_new?(file)
+          MTIMES[file].nil?
+        end
+
+        private
+        def with_silence
+          verbosity_level, $-v = $-v, nil
+          yield
+        ensure
+          $-v = verbosity_level
+        end
+      end
+    end
+  end
+end

data/lib/grape/reload.rb

@@ -0,0 +1,2 @@
+require "grape/reload/version"
+require "grape/reload/rack_builder"

data/lib/ripper/extract_constants.rb

@@ -0,0 +1,335 @@
+require 'ripper'
+require 'forwardable'
+
+class TraversingContext
+  extend Forwardable
+  attr_reader :module, :options
+  def_instance_delegators :'@options', :'[]', :'[]='
+
+  def initialize(mod = [], options = {})
+    @module = mod
+    @options = options
+  end
+
+  def push_modules(*modules)
+    @module = @module.concat(modules)
+  end
+
+  def module_name
+    @module.join('::')
+  end
+
+  def full_class_name(class_name)
+    module_name + '::' + class_name
+  end
+end
+
+class TraversingResult
+  attr_reader :namespace, :declared, :used, :parent, :children
+  def initialize(namespace = nil, parent = nil)
+    @declared = []
+    @used = []
+    @parent = parent
+    @namespace = namespace
+    @children = []
+  end
+
+  def declare_const(const)
+    @declared << const
+  end
+
+  def use_const(const, analyze = true)
+    if analyze
+      return if @used.map{|a| a.last }.include?(const)
+      if const.start_with?('::')
+        @used << [const]
+      else
+        const_ary = const.split('::')
+        variants = []
+        if const_ary.first == namespace
+          (variants << const_ary.dup).last.shift
+        else
+          (variants << const_ary.dup).last.unshift(@namespace) unless @namespace.nil?
+        end
+
+        variants << [ const_ary ]
+        @used << variants.map{|v| v.join('::')}
+      end
+    else
+      @used << const
+    end
+  end
+
+  def nest(namespace)
+    r = TraversingResult.new(namespace, self)
+    @children << r
+    r
+  end
+
+  def used; @used end
+  def declared; @declared end
+
+  def full_namespace
+    p = self
+    namespace_parts = []
+    namespace_parts << p.namespace if p.namespace
+    unless p.parent.nil?
+      p = p.parent
+      namespace_parts.unshift(p.namespace) if p.namespace
+    end
+
+    namespace_parts
+  end
+
+  def extract_consts
+    result = {
+        declared: declared.map{|d| (namespace || '') + '::' + d },
+        used: []
+    }
+
+    @children.map(&:extract_consts).each{|c|
+       result[:declared] = result[:declared].concat(c[:declared].map{|d| (namespace || '') + '::' + d })
+       result[:used] = result[:used].concat(c[:used].map!{|_| _.map!{|v|
+                 if v.start_with?('::') || (namespace && v.start_with?(namespace + '::'))
+                   v
+                 else
+                   (namespace || '') + '::' + v
+                 end
+               } })
+    }
+
+    result[:used] = result[:used].reject {|variants|
+      !variants.find{|v| result[:declared].include?(v) }.nil?
+    }
+
+    used = self.used.reject {|variants|
+      !variants.find{|v| result[:declared].include?(v) }.nil?
+    }
+
+    if namespace
+      ns_variants = [namespace+'::']
+      full_namespace[0..-2].reverse.each{|ns| ns_variants << ns + '::' + ns_variants.last}
+      used.each do |variants|
+        # variants = variants.reject{ |v|
+        #   !ns_variants.find{|ns_part| v.start_with?(ns_part) }.nil?
+        # }
+        result[:used] = result[:used] << variants
+      end
+    else
+      result[:used] = result[:used].concat(used)
+    end
+
+    result
+  end
+end
+
+class ASTEntity
+  class << self
+    def ripper_id; raise 'Override ripper_id method with ripper id value' end
+    def inherited(subclass)
+      node_classes << subclass
+    end
+    def node_classes
+      @node_classes ||= []
+    end
+    def node_classes_cache
+      return @node_classes_cache if @node_classes_cache
+      @node_classes_cache = Hash[node_classes.map(&:ripper_id).zip(node_classes)]
+    end
+    def node_for(node_ary)
+      if node_classes_cache[node_ary.first]
+        node_classes_cache[node_ary.first].new(*node_ary[1..-1])
+      else
+        if node_ary.first.kind_of?(Symbol)
+          load(node_ary)
+        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) }
+        end
+      end
+    end
+    def load(node)
+      new(*node[1..-1])
+    end
+  end
+
+  def initialize(*args)
+    @body = args.map{ |node_ary|
+      ASTEntity.node_for(node_ary) if node_ary.kind_of?(Array)
+    }
+  end
+
+  def collect_constants(result, context = nil)
+    result ||= TraversingResult.new
+    @body.each{|e|
+      case e
+        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? }
+        else
+      end
+    } unless @body.nil?
+    result
+  end
+end
+
+class ASTProgramDecl < ASTEntity
+  def self.ripper_id; :program end
+  def initialize(*args)
+    @body = args.first.map{|a| ASTEntity.node_for(a)}
+  end
+end
+
+
+class ASTBody < ASTEntity
+  def self.ripper_id; :bodystmt end
+  def initialize(*args)
+    @body = args.first.map{ |node| ASTEntity.node_for(node) }
+  end
+  def collect_constants(result, context)
+    context[:variable_assignment] = false
+    super(result, context)
+  end
+end
+
+class ASTClass < ASTEntity
+  def self.ripper_id; :class end
+  def collect_constants(result, context)
+    context[:variable_assignment] = true
+    super(result, context)
+  end
+end
+
+class ASTConstRef < ASTEntity
+  def self.ripper_id; :const_ref end
+  def initialize(*args)
+    @const_name = args[0][1]
+  end
+  def collect_constants(result, context)
+    result.declare_const(@const_name)
+    super(result, context)
+  end
+end
+
+class ASTTopConstRef < ASTEntity
+  def self.ripper_id; :top_const_ref end
+  def collect_constants(result, context)
+    context[:top] = true
+    super(result, context)
+    context[:top] = false
+  end
+end
+
+class ASTArgsAddBlock < ASTEntity
+  def self.ripper_id; :args_add_block end
+  def initialize(*args)
+    super(*args.flatten(1))
+  end
+end
+
+class ASTBareAssocHash < ASTEntity
+  def self.ripper_id; :bare_assoc_hash end
+  def initialize(*args)
+    super(*args.flatten(2))
+  end
+end
+
+class ASTArray < ASTEntity
+  def self.ripper_id; :array end
+  def initialize(*args)
+    super(*args.flatten(1))
+  end
+end
+
+class ASTConst < ASTEntity
+  def self.ripper_id; :'@const' end
+  def initialize(*args)
+    @const_name = args[0]
+  end
+  def collect_constants(result, context)
+    if context[:variable_assignment]
+      result.declare_const(@const_name)
+    else
+      analyze_const = context[:analyze_const].nil? ? true  : context[:analyze_const]
+      if context[:top]
+        result.use_const('::'+@const_name)
+      else
+        result.use_const(@const_name, analyze_const)
+      end
+
+    end
+
+    super(result, context)
+  end
+end
+
+class ASTConstPathRef < ASTEntity
+  def self.ripper_id; :const_path_ref end
+  def initialize(*args)
+    @path = ASTEntity.node_for(args.first)
+    @const = ASTEntity.node_for(args.last)
+  end
+  def collect_constants(result, context)
+    if context[:const_path_ref]
+      r = TraversingResult.new
+      c = context.dup
+      c[:analyze_const] = false
+      path_consts = @path.collect_constants(r, context)
+      const = @const.collect_constants(r, context)
+      result.use_const(path_consts.used.join('::'), false)
+    else
+      r = TraversingResult.new
+      new_context = TraversingContext.new([], {const_path_ref: true, analyze_const: false})
+      path_consts = @path.collect_constants(r, new_context)
+      const = @const.collect_constants(r, new_context)
+      result.use_const(path_consts.used.join('::'))
+    end
+    result
+  end
+end
+
+class ASTModule < ASTEntity
+  def self.ripper_id; :module end
+  def initialize(*args)
+    @module_name = args.find{|a| a.first == :const_ref}.last[1]
+    @body = args.find{|a| a.first == :bodystmt}[1].map{|node|
+      ASTEntity.node_for(node)
+    }
+  end
+  def collect_constants(result, context)
+    result = result.nest(@module_name)
+    context.module << @module_name
+    super(result, context)
+  end
+end
+
+class ASTVarField < ASTEntity
+  def self.ripper_id; :var_field end
+  def collect_constants(result, context)
+    context[:variable_assignment] = true
+    super(result, context)
+    context[:variable_assignment] = false
+  end
+end
+
+class ASTRef < ASTEntity
+  def self.ripper_id; :var_ref end
+  def collect_constants(result, context)
+    context[:variable_assignment] = false
+    super(result, context)
+  end
+end
+
+
+class Ripper
+  def self.extract_constants(code)
+    ast = Ripper.sexp(code)
+    result = ASTEntity.node_for(ast).collect_constants(TraversingResult.new)
+    consts = result.extract_consts
+    consts[:declared].flatten!
+    consts[:declared].uniq!
+    consts
+  end
+end

data/spec/fixtures/app1/mounts/lib.rb

@@ -0,0 +1,9 @@
+module Test
+  class LibMount1 < Grape::API
+    desc 'Some test description',
+         entity: [Test::Lib1]
+    get :lib_string do
+      Test::Lib1.get_lib_string
+    end
+  end
+end

data/spec/fixtures/app1/mounts/mount.rb

@@ -0,0 +1,7 @@
+module Test
+  class Mount1 < Grape::API
+    get :test1 do
+      'mounted test1' #changed: 'mounted test1 changed'
+    end
+  end
+end

data/spec/fixtures/app1/test1.rb

@@ -0,0 +1,10 @@
+module Test
+  class App1 < Grape::API
+    format :txt
+    mount Test::Mount1 => '/mounted'
+    #changed: mount Test::LibMount1 => '/lib_mounted'
+    get :test do
+      'test1 response' #changed: 'test1 response changed'
+    end
+  end
+end

data/spec/fixtures/app2/mounts/lib.rb

@@ -0,0 +1,7 @@
+module Test
+  class LibMount2 < Grape::API
+    get :lib_string do
+      Test::Lib2.get_lib_string
+    end
+  end
+end

data/spec/fixtures/app2/mounts/mount.rb

@@ -0,0 +1,5 @@
+module Test
+  class Mount2 < Grape::API
+
+  end
+end

data/spec/fixtures/app2/test2.rb

@@ -0,0 +1,12 @@
+module Test
+  class App2 < Grape::API
+    format :txt
+    mount Test::Mount2 => '/mounted'
+    # mount Test::Mount10 => '/mounted2'
+    mount Test::LibMount2 => '/lib_mounted'
+    #changed: mount Test::LibMount2 => '/lib_mounted'
+    get :test do
+      'test2 response' #changed: 'test2 response changed'
+    end
+  end
+end

data/spec/fixtures/lib/lib1.rb

@@ -0,0 +1,7 @@
+module Test
+  class Lib1
+    def self.get_lib_string
+      'lib string 1' # changed: 'lib string 1 changed'
+    end
+  end
+end

data/spec/fixtures/lib/lib2.rb

@@ -0,0 +1,7 @@
+module Test
+  class Lib2
+    def self.get_lib_string
+      'lib string 2' # changed: lib string 2 changed
+    end
+  end
+end

data/spec/grape/reload/autoreload_interceptor_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require_relative '../../../lib/grape/reload/grape_api'
+describe Grape::Reload::AutoreloadInterceptor do
+  let(:api_class) {
+    nested_class = Class.new(Grape::API) do
+      get :route do
+        'nested route'
+      end
+    end
+
+    Class.new(Grape::API) do
+      format :txt
+      get :test_route do
+        'test'
+      end
+      mount nested_class => '/nested'
+    end
+  }
+
+  describe '.reinit!' do
+    let(:app) {
+      app = Rack::Builder.new
+      app.run api_class
+      app
+    }
+    it 'exists' do
+      expect(api_class).to respond_to('reinit!')
+    end
+
+    it 'reinit Grape API declaration' do
+      get '/test_route'
+      expect(last_response).to succeed
+      expect(last_response.body).to eq('test')
+      api_class.reinit!
+      get '/test_route'
+      expect(last_response).to succeed
+      expect(last_response.body).to eq('test')
+    end
+  end
+end

data/spec/grape/reload/dependency_map_spec.rb

@@ -0,0 +1,30 @@
+require 'grape'
+require 'spec_helper'
+
+describe Grape::Reload::DependencyMap do
+  let!(:file_class_map) {
+    {
+        'file1' => {
+            declared: ['::Class1'],
+            used: [],
+        },
+        'file2' => {
+            declared: ['::Class2'],
+            used: ['::Class1','::Class3'],
+        },
+        'file3' => {
+            declared: ['::Class3'],
+            used: ['::Class2'],
+        },
+    }
+  }
+  let!(:dm) { Grape::Reload::DependencyMap.new([]) }
+
+  it 'resolves dependent classes properly' do
+    allow(dm).to receive(:map).and_return(file_class_map)
+    # map = instance_double(Grape::Reload::DependencyMap)
+    # allow(map).to receive(:map).and_return(file_class_map)
+
+    expect(dm.dependent_classes('file1')).to include('::Class2','::Class3')
+  end
+end

data/spec/grape/reload/rack_builder_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Grape::RackBuilder do
+  let(:builder) {
+    Module.new do
+      class << self
+        include Grape::RackBuilder::ClassMethods
+        def get_config
+          config
+        end
+      end
+    end
+  }
+
+  before do
+    builder.setup do
+      environment 'development'
+      add_source_path File.expand_path('**/*.rb', APP_ROOT)
+    end
+  end
+  before :each do
+    builder.get_config.mounts.clear
+  end
+
+  describe '.setup' do
+    subject(:config){ builder.get_config }
+
+    it 'configures builder with options' do
+      expect(config.sources).to include(File.expand_path('**/*.rb', APP_ROOT))
+      expect(config.environment).to eq('development')
+    end
+
+    it 'allows to mount bunch of grape apps to different roots' do
+      builder.setup do
+        mount 'TestClass1', to: '/test1'
+        mount 'TestClass2', to: '/test2'
+      end
+      expect(config.mounts.size).to eq(2)
+    end
+  end
+  #
+  describe '.boot!' do
+    before(:each) do
+      builder.setup do
+        mount 'Test::App1', to: '/test1'
+        mount 'Test::App2', to: '/test2'
+      end
+    end
+
+    it 'autoloads mounted apps files' do
+      expect{ builder.boot! }.to_not raise_error
+      expect(defined?(Test::App1)).not_to be_nil
+      expect(defined?(Test::App2)).not_to be_nil
+    end
+
+    it 'autoloads apps dependencies, too' do
+      expect{ builder.boot! }.to_not raise_error
+      expect(defined?(Test::Mount1)).not_to be_nil
+      expect(defined?(Test::Mount2)).not_to be_nil
+    end
+  end
+
+  describe '.application' do
+    before(:each) do
+      builder.setup do
+        mount 'Test::App1', to: '/test1'
+        mount 'Test::App2', to: '/test2'
+      end
+      builder.boot!
+    end
+    it 'creates Rack::Builder application' do
+      expect{ @app = builder.application }.not_to raise_error
+      expect(@app).to be_an_instance_of(Rack::Builder)
+      def @app.get_map; @map end
+      expect(@app.get_map.keys).to include('/test1','/test2')
+    end
+  end
+end