RubyGems - poolparty - Versions diffs - 0.2.69 → 0.2.84 - Mend

@@ -1,388 +0,0 @@
-%% This library is free software; you can redistribute it and/or modify
-%% it under the terms of the GNU Lesser General Public License as
-%% published by the Free Software Foundation; either version 2 of the
-%% License, or (at your option) any later version.
-%%
-%% This library is distributed in the hope that it will be useful, but
-%% WITHOUT ANY WARRANTY; without even the implied warranty of
-%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-%% Lesser General Public License for more details.
-%%
-%% You should have received a copy of the GNU Lesser General Public
-%% License along with this library; if not, write to the Free Software
-%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-%% USA
-%%
-%% $Id:$
-%%
-%% @private (for now)
-%% @author Richard Carlsson <richardc@it.uu.se>
-%% @copyright 2006 Richard Carlsson
-%% @doc Erlang automatic code loading service
--module(autoload).
--export([start/0, start/1, stop/0, stop/1,
-	 watch_module/1, watch_module/2, watch_module/3,
-	 watch_file/1, watch_file/2, watch_file/3,
-	 watch_dir/1, watch_dir/2, watch_dir/3
-	]).
--include_lib("kernel/include/file.hrl").
--define(SERVER, autoload).
--define(ZERO_TIMESTAMP, {0,0,0}).
-%% TODO: un-watching functionality
-%% We're not trying to provide strong guarantees here. The autoloader is
-%% supposed to behave like a human assistant might - race conditions may
-%% cause modules to be reloaded twice, or cause a reload from the wrong
-%% file (if paths are suddenly changed).
-watch_dir(Path) ->
-    watch_dir(Path, []).
-watch_dir(Path, Opts) ->
-    watch_dir(?SERVER, Path, Opts).
-watch_dir(Server, Path, Opts) ->
-    command(Server, {watch, {dir, filename:flatten(Path)}, Opts}).
-watch_file(Path) ->
-    watch_file(Path, []).
-watch_file(Path, Opts) ->
-    watch_file(?SERVER, Path, Opts).
-watch_file(Server, Path, Opts) ->
-    command(Server, {watch, {file, filename:flatten(Path)}, Opts}).
-watch_module(Module) ->
-    watch_module(Module, []).
-watch_module(Module, Opts) ->
-    watch_module(?SERVER, Module, Opts).
-watch_module(Server, Module, Opts) when is_atom(Module) ->
-    command(Server, {watch, {module, Module}, Opts}).
-command(Server, Msg) ->
-    ServerPid = ensure_started(Server),
-    ServerPid ! {command, self(), Msg},
-    receive
-	{ServerPid, Result} -> Result
-    end.
-stop() ->
-    stop(?SERVER).
-stop(Server) ->
-    Server ! stop,
-    ok.
-ensure_started(Name) when is_atom(Name) ->
-    start(Name);
-ensure_started(Pid) when is_pid(Pid) ->
-    Pid.
-start() ->
-    start(?SERVER).
-start(Name) ->
-    case whereis(Name) of
-	undefined ->
-	    Parent = self(),
-	    Pid = spawn(fun () -> server_init(Name, Parent) end),
-	    receive
-		{Pid, ok} -> Pid;
-		{Pid, error} -> throw(no_server)
-	    end;
-	Pid -> Pid
-    end.
--record(state, {name, modules, files, dirs}).
--record(module, {time = ?ZERO_TIMESTAMP, file, opts = []}).
-server_init(Name, Parent) ->
-    Self = self(),
-    case catch register(Name, Self) of
-	true ->
-	    Parent ! {Self, ok},
-	    code_monitor:monitor(self()),
-	    server(#state{name = Name,
-			  modules = dict:new(),
-			  files = dict:new(),
-			  dirs = dict:new()});
-	_ ->
-	    init_failure(Parent)
-    end.
-init_failure(Parent) ->
-    Parent ! {self(), error},
-    exit(failed).
-server(St) ->
-    receive
-	{file_monitor, _Ref, Msg} ->
-	    file_event(Msg, St);
-	{code_monitor, Msg} ->
-	    code_event(Msg, St);
-	{command, From, Cmd} ->
-	    server_command(From, Cmd, St);
-	stop ->
-	    exit(normal);
-	Msg ->
-	    erlang:display({autoload_unexpected, Msg}),
-	    server(St)
-    end.
-server_command_reply(From, Msg) ->
-    From ! {self(), Msg}.
-server_command(From, {watch, {dir, Path}, Opts}, St) ->
-    server_command_reply(From, ok),
-    server(monitor_dir(Path, Opts, St));
-server_command(From, {watch, {file, Path}, Opts}, St) ->
-    server_command_reply(From, ok),
-    server(monitor_file(Path, Opts, St));
-server_command(From, {watch, {module, M}, Opts}, St) ->
-    server_command_reply(From, ok),
-    server(monitor_module(M, Opts, St)).
-file_event({exists, Path, dir, _Info, Files}, St) ->
-    %%erlang:display({autoload_saw_exists, dir, Path}),
-    server(monitor_objs(Path, Files, St));
-file_event({exists, Path, file, Info, _}, St) ->
-    %%erlang:display({autoload_saw_exists, file, Path}),
-    %% treat file-exists messages just like file-changed messages
-    server(changed_file(Path, Info#file_info.mtime, St));
-file_event({changed, Path, dir, _Info, Files}, St) ->
-    %%erlang:display({autoload_saw_changed, dir, Path}),
-    server(monitor_objs(Path, Files, St));
-file_event({changed, Path, file, #file_info{}=Info, _}, St) ->
-    %%erlang:display({autoload_saw_changed, file, Path}),
-    server(changed_file(Path, Info#file_info.mtime, St));
-file_event({error, _Path, file, _ErrorAtom}=_Msg, St) ->
-    %%erlang:display({autoload_ignoring, _Msg}),
-    %% just consider the files as being temporarily unavailable
-    server(St);
-file_event(_Msg, St) ->
-    erlang:display({autoload_unexpected_file_event, _Msg}),
-    server(St).
-code_event({loaded, M, Time}, St) ->
-    %%erlang:display({autoload_saw_loaded, M, Time}),
-    server(loaded_module(M, Time, St));
-code_event(_Msg, St) ->
-    erlang:display({autoload_unexpected_code_event, _Msg}),
-    server(St).
-%% called when asked to watch a module M
-monitor_module(M, Opts, St) ->
-    ensure_loaded(M, "", Opts),
-    case code:which(M) of
-	non_existing ->
-	    %% no module loaded or found in path (e.g., the user has not
-	    %% run 'make' yet, or has not updated the path): store
-	    %% mapping from M to undefined file, for late binding
-	    store_record(M, #module{opts = Opts}, St);
-	File when is_list(File) ->
-	    %% existing file found (already loaded or in path): monitor
-	    %% the file and map M to that file (even if the first load
-	    %% might turn out to be from another file)
-	    store_record(M, #module{file = File},
-			 monitor_file(File, Opts, St));
-	_ ->
-	    %% preloaded or cover-compiled module - ignore
-	    St
-    end.
-%% called when a monitored directory is detected as new or changed
-monitor_objs(Path, Files, St) ->
-    Opts = get_dir_opts(Path, St),
-    ObjExt = file:objfile_extension(),
-    Objs = [F || {added, F} <- Files, filename:extension(F) == ObjExt],
-    lists:foldl(
-      fun (F, St) ->
-	      F1 = filename:absname(filename:join(Path, F)),
-	      %%erlang:display({autoload_monitoring, file, F1}),
-	      monitor_file(F1, Opts, St)
-      end,
-      St,
-      Objs).
-get_dir_opts(Path, St) ->
-    case dict:find(Path, St#state.dirs) of
-	{ok, {_Ref, Opts}} -> Opts;
-	error -> []
-    end.
-%% called when a module was detected as loaded or reloaded (either
-%% caused by an auto-load or by someone else)
-loaded_module(M, Time, St) ->
-    case find_record(M, St) of
-	{ok, R} ->
-	    File = code:which(M),
-	    case R#module.file of
-		undefined when is_list(File) ->
-		    %% a watched module gets a late binding to a file
-		    %%erlang:display({autoload_late_binding, M, File}),
-		    Opts = R#module.opts,
-		    update_record(M, R, Time, File,
-				  monitor_file(File, Opts, St));
-		File when is_list(File) ->
-		    %% loaded from watched file - update the load time
-		    update_record(M, R, Time, File, St);
-		_ ->
-		    St    %% not loaded from the watched file
-	    end;
-	error ->
-	    St    %% uninteresting module
-    end.
-%% called whenever a file has changed and exists
-changed_file(File, Time, St) ->
-    %% always reread the module name from the file
-    case obj_module(File) of
-	{module, M} ->
-	    case find_record(M, St) of
-		{ok, R} ->
-		    check_reload(M, File, Time, R),
-		    St;
-		error ->
-		    %% first time we see this module: map to file
-		    %% and don't try to reload
-		    R = #module{file = File},
-		    store_record(M, R, St)
-	    end;
-	error ->
-	    St    %% bad file - ignore until changed again
-    end.
-%% check if a module needs to be reloaded, when its file has changed
-check_reload(M, File, Time, R) ->
-    %%erlang:display({autoload_checking, M, File, Time, R}),
-    case ((R#module.file == File)
-	  andalso is_loaded(M)
-	  andalso (code:which(M) == File)
-	  andalso is_newer(Time, R#module.time))
-	of
-	true ->
-	    reload(M);
-	false ->
-	    ok
-    end.
-reload(M) ->
-    erlang:display({autoload_loading, M}),
-    code:purge(M),
-    code:load_file(M).
-update_record(M, R, Time, File, St) ->
-    store_record(M, R#module{time = Time, file = File}, St).
-find_record(M, St) ->
-    dict:find(M, St#state.modules).
-store_record(M, R, St) ->
-    St#state{modules = dict:store(M, R, St#state.modules)}.
-%% we must remember watched files/dirs, so we don't set up more than one
-%% file monitor for the same path, and so we can cancel monitors; for
-%% dirs, we also remember options
-monitor_file(Path, Opts, St) ->
-    ensure_loaded([], Path, Opts),
-    case dict:is_key(Path, St#state.files) of
-	true ->
-	    %%erlang:display({autoload_already_watching, Path}),
-	    St;
-	false ->
-	    {ok, _, Ref} = file_monitor:monitor_file(Path, self()),
-	    St#state{files = dict:store(Path, Ref, St#state.files)}
-    end.
-monitor_dir(Path, Opts, St) ->
-    case dict:is_key(Path, St#state.dirs) of
-	true ->
-	    %%erlang:display({autoload_already_watching, Path}),
-	    St;
-	false ->
-	    {ok, _, Ref} = file_monitor:monitor_dir(Path, self()),
-	    St#state{dirs = dict:store(Path, {Ref, Opts},
-				       St#state.dirs)}
-    end.
-%% try to ensure that a module/file is loaded (M is [] if unknown;
-%% File is "" if unknown)
-ensure_loaded(M, File, Opts) ->
-    case proplists:get_bool(load, Opts) of
-	true when is_atom(M) ->
-	    ensure_loaded_1(M, File);  %% known module name
-	true when M == [] ->
-	    case obj_module(File) of
-		{module, Module} ->
-		    ensure_loaded_1(Module, File);
-		error ->
-		    ok  %% couldn't load
-	    end;
-	false -> ok
-    end.
-ensure_loaded_1(M, File) ->
-    %% always try to load using the path first
-    case code:ensure_loaded(M) of
-	{module, _} ->
-	    ok;
-	{error, _} when File == [] ->
-	    ok;  %% ignore error
-	{error, _} ->
-	    %% try loading directly from the file
-	    code:load_abs(File)  %% ignore result
-    end.
-%% find name of module stored in an object file
-obj_module(File) ->
-    case beam_lib:info(File) of
-	List when is_list(List) ->
-	    case lists:keysearch(module, 1, List) of
-		{value, {module, M}} ->
-		    {module, M};
-		_ ->
-		    error
-	    end;
-	_ ->
-	    error
-    end.
-%% check if the file timestamp (on DateTime format) is newer than
-%% the module load-time (on Now-format)
-is_newer(DateTime, LoadTime) ->
-    calendar:datetime_to_gregorian_seconds(DateTime) >
-	calendar:datetime_to_gregorian_seconds(
-	  calendar:now_to_local_time(LoadTime)).
-%% wrapper for code:is_loaded/1
-is_loaded(Module) ->
-    case code:is_loaded(Module) of
-	{file, _} -> true;
-	false -> false
-    end.

data/lib/erlang/messenger/lib/eunit/src/.svn/text-base/code_monitor.erl.svn-base DELETED Viewed

@@ -1,243 +0,0 @@
-%% This library is free software; you can redistribute it and/or modify
-%% it under the terms of the GNU Lesser General Public License as
-%% published by the Free Software Foundation; either version 2 of the
-%% License, or (at your option) any later version.
-%%
-%% This library is distributed in the hope that it will be useful, but
-%% WITHOUT ANY WARRANTY; without even the implied warranty of
-%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-%% Lesser General Public License for more details.
-%%
-%% You should have received a copy of the GNU Lesser General Public
-%% License along with this library; if not, write to the Free Software
-%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-%% USA
-%%
-%% $Id:$
-%%
-%% @private (for now)
-%% @author Richard Carlsson <richardc@it.uu.se>
-%% @copyright 2006 Richard Carlsson
-%% @doc Erlang code monitoring service
--module(code_monitor).
--export([start/0, start/1, stop/0, stop/1, monitor/1, monitor/2,
-	 demonitor/1, demonitor/2, install_codespy/1, wiretap/3]).
--export([main/1]).    %% private
--define(SERVER, code_monitor).
-monitor(Pid) ->
-    monitor(?SERVER, Pid).
-monitor(Server, Pid) when is_pid(Pid) ->
-    ensure_started(Server),
-    Server ! {monitor, Pid},
-    ok.
-demonitor(Pid) ->
-    demonitor(?SERVER, Pid).
-demonitor(Server, Pid) when is_pid(Pid) ->
-    ensure_started(Server),
-    Server ! {demonitor, Pid},
-    ok.
-stop() ->
-    stop(?SERVER).
-stop(Server) ->
-    Server ! stop,
-    ok.
-ensure_started(Name) when is_atom(Name) ->
-    start(Name);
-ensure_started(Pid) when is_pid(Pid) ->
-    Pid.
-start() ->
-    start(?SERVER).
-start(Name) ->
-    case whereis(Name) of
-	undefined ->
-	    Parent = self(),
-	    Pid = spawn(fun () -> server_init(Name, Parent) end),
-	    receive
-		{Pid, ok} -> Pid;
-		{Pid, error} -> throw(no_server)
-	    end;
-	Pid -> Pid
-    end.
-server_init(undefined = Name, Parent) ->
-    %% anonymous server
-    server_init_1(Name, Parent);
-server_init(Name, Parent) ->
-    case catch register(Name, self()) of
-	true ->
-	    server_init_1(Name, Parent);
-	_ ->
-	    init_failure(Parent)
-    end.
-server_init_1(Name, Parent) ->
-    case install_codespy(self()) of
-	{ok, _Spy} ->
-	    Parent ! {self(), ok},
-	    server(Name, sets:new());
-	{error, _} ->
-	    init_failure(Parent)
-    end.
-init_failure(Parent) ->
-    Parent ! {self(), error},
-    exit(failed).
-server(Name, Listeners) ->
-    ?MODULE:main({Name, Listeners}).
-%% @private
-main({Name, Listeners}) ->
-    receive
-	{code_server, {module, M}} ->
-	    cast({loaded, M, erlang:now()}, Listeners),
-	    server(Name, Listeners);
-	{monitor, Pid} when is_pid(Pid) ->
-	    server(Name, sets:add_element(Pid, Listeners));
-	{demonitor, Pid} ->
-	    server(Name, sets:del_element(Pid, Listeners));
-	stop ->
-	    exit(normal);
-	_ ->
-	    server(Name, Listeners)
-    end.
-cast(M, Listeners) ->
-    sets:fold(fun (L, M) -> L ! M end, {code_monitor, M}, Listeners).
-%% code server spy process using generic wiretap functionality
-install_codespy(To) ->
-    wiretap(code_server, To, fun code_spy/3).
-code_spy({code_call,From,{load_file,_}=Req}, Server, To) ->
-    handle_load(Req, From, Req, Server, To);
-code_spy({code_call,From,{ensure_loaded,M}=Req}=Msg, Server, To) ->
-    case erlang:module_loaded(M) of
-	true -> Server ! Msg;
-	false -> handle_load(Req, From, Req, Server, To)
-    end;
-code_spy({code_call,From,{load_abs,_,_}=Req}, Server, To) ->
-    handle_load(Req, From, Req, Server, To);
-code_spy({code_call,From,{load_binary,_,_,_}=Req}, Server, To) ->
-    handle_load(Req, From, Req, Server, To);
-code_spy({code_call,From,{load_native_partial,_,_}=Req}, Server, To) ->
-    handle_load(Req, From, Req, Server, To);
-code_spy({code_call,From,{load_native_sticky,_,_,_}=Req}, Server, To) ->
-    handle_load(Req, From, Req, Server, To);
-code_spy(Msg, Server, _To) ->
-    Server ! Msg.
-handle_load(Req, From, Req, Server, To) ->
-    ReplyTo = spawn(fun () -> reply_handler(Server, From, To) end),
-    Server ! {code_call, ReplyTo, Req}.
-%% one-shot processes - receive, pass on and die
-reply_handler(Server, Client, To) ->
-    link(Server),
-    receive
-	{code_server, _Reply} = M ->
-	    To ! Client ! M
-    end.
-%% basic wiretapping of registered processes (it should be possible to
-%% have several wiretaps attached to the same registered name; they will
-%% transparently form a chain, without knowing about each other)
-wiretap(Name, To, F) when is_atom(Name), is_pid(To), is_function(F) ->
-    Parent = self(),
-    Pid = spawn(fun () -> wiretap_init(Name, To, F, Parent) end),
-    receive
-	{Pid, Result} -> Result
-    end.
-wiretap_init(Name, To, F, Parent) ->
-    case whereis(Name) of
-	undefined ->
-	    Parent ! {self(), {error, undefined}},
-	    exit(error);
-	Pid ->
-	    catch unregister(Name),
-	    catch register(Name, self()),
-	    Self = self(),
-	    case whereis(Name) of
-		Self ->
-		    process_flag(trap_exit, true),
-		    link(Pid),
-		    link(To),
-		    Parent ! {self(), {ok, self()}},
-		    wiretap_loop(Name, To, Pid, F);
-		_ ->
-		    Parent ! {self(), {error, register_failed}},
-		    exit(error)
-	    end
-    end.
-wiretap_loop(Name, To, Pid, F) ->
-    receive
-	{'EXIT', Pid, _} ->
-	    wiretap_dropped(Name, To, F);
-	{'EXIT', To, _} ->
-	    wiretap_exit(Name, Pid);
-	Msg ->
-	    F(Msg, Pid, To),
-	    wiretap_loop(Name, To, Pid, F)
-    end.
-%% note that the registered name might get stolen from the spy process,
-%% e.g., by another active wiretap
-wiretap_exit(Name, Pid) ->
-    %% the receiver died - restore things and go away invisibly
-    unlink(Pid),
-    Self = self(),
-    %% sadly, this is not atomic...
-    case whereis(Name) of
-	Self ->
-	    catch unregister(Name),
-	    catch register(Name, Pid);
-	_ -> ok
-    end,
-    exit(normal).
-%% if the real server goes away, make sure to unregister, and keep watch
-%% in order to restart the wiretap when the server comes up again
-wiretap_dropped(Name, To, F) ->
-    Self = self(),
-    case whereis(Name) of
-	Self -> (catch unregister(Name));
-	_ -> ok
-    end,
-    wiretap_watch(Name, To, F).
-wiretap_watch(Name, To, F) ->
-    receive
-	{'EXIT', To, _} ->
-	    exit(normal)
-    after 1000 ->
-	case whereis(Name) of
-	    Pid when is_pid(Pid) ->
-		%% this process will terminate after starting the
-		%% new wiretap (even it that call fails)
-		wiretap(Name, To, F),
-		exit(normal);
-	    _ ->
-		wiretap_watch(Name, To, F)
-	end
-    end.