Class: Ramaze::Reloader

Inherits:

Object

• Object
• Ramaze::Reloader

show all

Includes:

Hooks

Defined in:

lib/ramaze/reloader.rb,
lib/ramaze/reloader/watch_stat.rb,
lib/ramaze/reloader/watch_inotify.rb

Overview

Defined Under Namespace

Modules: Hooks Classes: WatchInotify, WatchStat

Constant Summary

OPTIONS =

{
  # At most check every n seconds
  # nil/false will never trigger the reload cycle
  # 0 will cycle on every call
  :cooldown => 2,

  # Compiled files cannot be reloaded during runtime
  :ignore => /\.so$/,

  # Run cycle in a Thread.exclusive, by default no threads are used.
  :thread => false,

  # If you assign a block here it will be instance_evaled instead of
  # calling cycle. This allows you to use for example EventMachine for
  # well performing asynchronous cycling.
  :control => nil, # lambda{ cycle },
}

Instance Method Summary (collapse)

• - (Object) call(env)

  Allows this class to be called as a Rack middleware.

• - (Object) cycle

  Loops through all the files and reloads all changes files.

• - (String) figure_path(file, paths)

  Tries to find a given file in an array of file paths.

• - (Reloader) initialize(app) constructor

  Creates a new instance of the class and saves the application it has to watch.

• - (Array) options_reload

  Returns all the options for this class.

• - (Object) rotation
• - (Object) safe_load(file)

  A safe Kernel::load, issuing the hooks depending on the results.

Methods included from Hooks

#after_cycle, #after_safe_load, #after_safe_load_failed, #after_safe_load_succeed, #before_cycle, #before_safe_load

71
72
73
74
75
76

# File 'lib/ramaze/reloader.rb', line 71

def initialize(app)
  @app = app
  @files = {}
  @watcher = Watcher.new
  options_reload
end

97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

# File 'lib/ramaze/reloader.rb', line 97

def call(env)
  options_reload

  @watcher.call(@cooldown) do
    if @control
      instance_eval(&@control)
    elsif @thread
      Thread.exclusive{ cycle }
    else
      cycle
    end
  end

  @app.call(env)
end

119
120
121
122
123
124
125
126

# File 'lib/ramaze/reloader.rb', line 119

def cycle
  before_cycle

  rotation{|file| @watcher.watch(file) }
  @watcher.changed_files{|f| safe_load(f) }

  after_cycle
end

166
167
168
169
170
171
172
173
174
175
176

# File 'lib/ramaze/reloader.rb', line 166

def figure_path(file, paths)
  if Pathname.new(file).absolute?
    return File.exist?(file) ? file : nil
  end

  paths.each do |possible_path|
    full_path = File.join(possible_path, file)
    return full_path if File.exist?(full_path)
  end
  nil
end

85
86
87
88

# File 'lib/ramaze/reloader.rb', line 85

def options_reload
  @cooldown, @ignore, @control, @thread =
    OPTIONS.values_at(:cooldown, :ignore, :control, :thread)
end

144
145
146
147
148
149
150
151
152
153
154
155

# File 'lib/ramaze/reloader.rb', line 144

def rotation
  files = [$0, __FILE__, *$LOADED_FEATURES].uniq
  paths = ['./', *$LOAD_PATH].uniq

  files.each do |file|
    next if file =~ @ignore
    if not @files.has_key?(file) and path = figure_path(file, paths)
      @files[file] = path
      yield path
    end
  end
end

135
136
137
138
139
140
141
142

# File 'lib/ramaze/reloader.rb', line 135

def safe_load(file)
  before_safe_load(file)
  load(file)
  after_safe_load_succeed(file)
rescue Object => ex
  Log.error(ex)
  after_safe_load_failed(file, ex)
end