ernie 1.3.0 → 2.0.0

data/elib/ernie_config.erl

@@ -0,0 +1,30 @@
+-module(ernie_config).
+-export([load/1]).
+
+load(ConfigFile) ->
+  {ok, Configs} = file:consult(ConfigFile),
+  Configs2 = lists:map((fun load_single/1), Configs),
+  {ok, Configs2}.
+
+load_single(Config) ->
+  case proplists:get_value(type, Config) of
+    native ->
+      verify(native, Config),
+      CodePaths = proplists:get_value(codepaths, Config),
+      lists:map((fun code:add_patha/1), CodePaths),
+      Mod = proplists:get_value(module, Config),
+      code:load_file(Mod),
+      [{id, native} | Config];
+    external ->
+      verify(external, Config),
+      Handler = proplists:get_value(command, Config),
+      Number = proplists:get_value(count, Config),
+      {ok, SupPid} = asset_pool_sup:start_link(Handler, Number),
+      [{_Id, ChildPid, _Type, _Modules}] = supervisor:which_children(SupPid),
+      [{id, ChildPid} | Config]
+  end.
+
+verify(native, _Config) ->
+  ok;
+verify(external, _Config) ->
+  ok.

data/elib/ernie_native.erl

@@ -0,0 +1,22 @@
+-module(ernie_native).
+-export([process/2]).
+-include_lib("ernie.hrl").
+
+process(ActionTerm, Request) ->
+  {_Type, Mod, Fun, Args} = ActionTerm,
+  Sock = Request#request.sock,
+  logger:debug("Calling ~p:~p(~p)~n", [Mod, Fun, Args]),
+  try apply(Mod, Fun, Args) of
+    Result ->
+      logger:debug("Result was ~p~n", [Result]),
+      Data = bert:encode({reply, Result}),
+      gen_tcp:send(Sock, Data)
+  catch
+    error:Error ->
+      BError = list_to_binary(io_lib:format("~p", [Error])),
+      Trace = erlang:get_stacktrace(),
+      BTrace = lists:map(fun(X) -> list_to_binary(io_lib:format("~p", [X])) end, Trace),
+      Data = term_to_binary({error, [user, 0, <<"RuntimeError">>, BError, BTrace]}),
+      gen_tcp:send(Sock, Data)
+  end,
+  ok = gen_tcp:close(Sock).

data/elib/ernie_server.erl

@@ -1,21 +1,14 @@
 -module(ernie_server).
 -behaviour(gen_server).
+-include_lib("ernie.hrl").
 
 %% api
--export([start_link/1, start/1, process/1, asset_freed/0]).
+-export([start_link/1, start/1, process/1, kick/0]).
 
 %% gen_server callbacks
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
          terminate/2, code_change/3]).
 
--record(state, {lsock = undefined,
-                pending = queue:new(),
-                count = 0}).
-
--record(request, {sock = undefined,
-                  info = undefined,
-                  action = undefined}).
-
 %%====================================================================
 %% API
 %%====================================================================
@@ -29,8 +22,8 @@ start(Args) ->
 process(Sock) ->
   gen_server:cast({global, ?MODULE}, {process, Sock}).
 
-asset_freed() ->
-  gen_server:cast({global, ?MODULE}, {asset_freed}).
+kick() ->
+  gen_server:cast({global, ?MODULE}, kick).
 
 %%====================================================================
 %% gen_server callbacks
@@ -43,12 +36,14 @@ asset_freed() ->
 %%                         {stop, Reason}
 %% Description: Initiates the server
 %%--------------------------------------------------------------------
-init([Port]) ->
+init([Port, Configs]) ->
   process_flag(trap_exit, true),
   error_logger:info_msg("~p starting~n", [?MODULE]),
   {ok, LSock} = try_listen(Port, 500),
   spawn(fun() -> loop(LSock) end),
-  {ok, #state{lsock = LSock}}.
+  Map = init_map(Configs),
+  io:format("pidmap = ~p~n", [Map]),
+  {ok, #state{lsock = LSock, map = Map}}.
 
 %%--------------------------------------------------------------------
 %% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
@@ -72,21 +67,19 @@ handle_cast({process, Sock}, State) ->
   Request = #request{sock = Sock},
   State2 = receive_term(Request, State),
   {noreply, State2};
-handle_cast({asset_freed}, State) ->
-  case queue:is_empty(State#state.pending) of
-    false ->
-      case asset_pool:lease() of
-        {ok, Asset} ->
-          {{value, Request}, Pending2} = queue:out(State#state.pending),
-          % io:format("d", []),
-          spawn(fun() -> process_now(Request, Asset) end),
-          {noreply, State#state{pending = Pending2}};
-        empty ->
-          % io:format(".", []),
+handle_cast(kick, State) ->
+  case queue:out(State#state.hq) of
+    {{value, Request}, Hq2} ->
+      State2 = process_request(Request, hq, Hq2, State),
+      {noreply, State2};
+    {empty, _Hq} ->
+      case queue:out(State#state.lq) of
+        {{value, Request}, Lq2} ->
+          State2 = process_request(Request, lq, Lq2, State),
+          {noreply, State2};
+        {empty, _Lq} ->
           {noreply, State}
-      end;
-    true ->
-      {noreply, State}
+      end
   end;
 handle_cast(_Msg, State) -> {noreply, State}.
 
@@ -101,6 +94,20 @@ code_change(_OldVersion, State, _Extra) -> {ok, State}.
 %% Internal
 %%====================================================================
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Module mapping
+
+init_map(Configs) ->
+  lists:map((fun extract_mapping/1), Configs).
+
+extract_mapping(Config) ->
+  Id = proplists:get_value(id, Config),
+  Mod = proplists:get_value(module, Config),
+  {Mod, Id}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Listen and loop
+
 try_listen(Port, 0) ->
   error_logger:error_msg("Could not listen on port ~p~n", [Port]),
   {error, "Could not listen on port"};
@@ -122,25 +129,8 @@ loop(LSock) ->
   ernie_server:process(Sock),
   loop(LSock).
 
-process_admin(Sock, reload_handlers, _Args, State) ->
-  asset_pool:reload_assets(),
-  gen_tcp:send(Sock, term_to_binary({reply, <<"Handlers reloaded.">>})),
-  ok = gen_tcp:close(Sock),
-  State;
-process_admin(Sock, stats, _Args, State) ->
-  Count = State#state.count,
-  CountString = list_to_binary([<<"connections.total=">>, integer_to_list(Count), <<"\n">>]),
-  IdleWorkers = asset_pool:idle_worker_count(),
-  IdleWorkersString = list_to_binary([<<"workers.idle=">>, integer_to_list(IdleWorkers), <<"\n">>]),
-  QueueLength = queue:len(State#state.pending),
-  QueueLengthString = list_to_binary([<<"connections.pending=">>, integer_to_list(QueueLength), <<"\n">>]),
-  gen_tcp:send(Sock, term_to_binary({reply, list_to_binary([CountString, IdleWorkersString, QueueLengthString])})),
-  ok = gen_tcp:close(Sock),
-  State;
-process_admin(Sock, _Fun, _Args, State) ->
-  gen_tcp:send(Sock, term_to_binary({reply, <<"Admin function not supported.">>})),
-  ok = gen_tcp:close(Sock),
-  State.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Receive and process
 
 receive_term(Request, State) ->
   Sock = Request#request.sock,
@@ -151,61 +141,136 @@ receive_term(Request, State) ->
       logger:info("Got term: ~p~n", [Term]),
       case Term of
         {call, '__admin__', Fun, Args} ->
-          process_admin(Sock, Fun, Args, State);
-        {info, _Command, _Args} ->
-          Request2 = Request#request{info = BinaryTerm},
-          receive_term(Request2, State);
+          ernie_admin:process(Sock, Fun, Args, State);
+        {info, Command, Args} ->
+          Infos = Request#request.infos,
+          Infos2 = [BinaryTerm | Infos],
+          Request2 = Request#request{infos = Infos2},
+          Request3 = process_info(Request2, Command, Args),
+          receive_term(Request3, State);
         _Any ->
           Request2 = Request#request{action = BinaryTerm},
-          process_request(Request2, State)
+          close_if_cast(Term, Request2),
+          case Request2#request.priority of
+            high ->
+              Hq2 = queue:in(Request2, State#state.hq),
+              Lq2 = State#state.lq;
+            low ->
+              Hq2 = State#state.hq,
+              Lq2 = queue:in(Request2, State#state.lq)
+          end,
+          ernie_server:kick(),
+          State#state{hq = Hq2, lq = Lq2}
       end;
     {error, closed} ->
       ok = gen_tcp:close(Sock),
       State
   end.
 
-process_request(Request, State) ->
-  ActionTerm = binary_to_term(Request#request.action),
+process_info(Request, priority, [Priority]) ->
+  Request#request{priority = Priority};
+process_info(Request, _Command, _Args) ->
+  Request.
+
+process_request(Request, Priority, Q2, State) ->
+  ActionTerm = bert:decode(Request#request.action),
+  {_Type, Mod, _Fun, _Args} = ActionTerm,
+  Specs = lists:filter(fun({X, _Id}) -> Mod =:= X end, State#state.map),
+  process_module(ActionTerm, Specs, Request, Priority, Q2, State).
+
+process_module(ActionTerm, [], Request, Priority, Q2, State) ->
+  {_Type, Mod, _Fun, _Args} = ActionTerm,
+  logger:debug("No such module ~p~n", [Mod]),
+  Sock = Request#request.sock,
+  Class = <<"ServerError">>,
+  Message = list_to_binary(io_lib:format("No such module '~p'", [Mod])),
+  gen_tcp:send(Sock, term_to_binary({error, [server, 0, Class, Message, []]})),
+  ok = gen_tcp:close(Sock),
+  finish(Priority, Q2, State);
+process_module(ActionTerm, Specs, Request, Priority, Q2, State) ->
+  [{_Mod, Id} | OtherSpecs] = Specs,
+  case Id of
+    native ->
+      logger:debug("Dispatching to native module~n", []),
+      {_Type, Mod, Fun, Args} = ActionTerm,
+      case erlang:function_exported(Mod, Fun, length(Args)) of
+        false ->
+          logger:debug("Not found in native module ~p~n", [Mod]),
+          process_module(ActionTerm, OtherSpecs, Request, Priority, Q2, State);
+        true ->
+          PredFun = list_to_atom(atom_to_list(Fun) ++ "_pred"),
+          logger:debug("Checking ~p:~p(~p) for selection.~n", [Mod, PredFun, Args]),
+          case erlang:function_exported(Mod, PredFun, length(Args)) of
+            false ->
+              logger:debug("No such predicate function ~p:~p(~p).~n", [Mod, PredFun, Args]),
+              process_native_request(ActionTerm, Request, Priority, Q2, State);
+            true ->
+              case apply(Mod, PredFun, Args) of
+                false ->
+                  logger:debug("Predicate ~p:~p(~p) returned false.~n", [Mod, PredFun, Args]),
+                  process_module(ActionTerm, OtherSpecs, Request, Priority, Q2, State);
+                true ->
+                  logger:debug("Predicate ~p:~p(~p) returned true.~n", [Mod, PredFun, Args]),
+                  process_native_request(ActionTerm, Request, Priority, Q2, State)
+              end
+          end
+      end;
+    ValidPid when is_pid(ValidPid) ->
+      logger:debug("Found external pid ~p~n", [ValidPid]),
+      process_external_request(ValidPid, Request, Priority, Q2, State)
+  end.
+
+close_if_cast(ActionTerm, Request) ->
   case ActionTerm of
     {cast, _Mod, _Fun, _Args} ->
       Sock = Request#request.sock,
       gen_tcp:send(Sock, term_to_binary({noreply})),
       ok = gen_tcp:close(Sock),
-      logger:debug("Closing cast.~n", []);
+      logger:debug("Closed cast.~n", []);
     _Any ->
       ok
-  end,
-  case queue:is_empty(State#state.pending) of
-    false ->
-      Pending2 = queue:in(Request, State#state.pending),
-      % io:format("Q", []),
-      State#state{pending = Pending2};
-    true ->
-      try_process_now(Request, State)
   end.
 
-try_process_now(Request, State) ->
+finish(Priority, Q2, State) ->
+  case Priority of
+    hq -> State#state{hq = Q2};
+    lq -> State#state{lq = Q2}
+  end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Native
+
+process_native_request(ActionTerm, Request, Priority, Q2, State) ->
+  Count = State#state.count,
+  State2 = State#state{count = Count + 1},
+  logger:debug("Count = ~p~n", [Count + 1]),
+  spawn(fun() -> ernie_native:process(ActionTerm, Request) end),
+  finish(Priority, Q2, State2).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% External
+
+process_external_request(Pid, Request, Priority, Q2, State) ->
   Count = State#state.count,
   State2 = State#state{count = Count + 1},
-  case asset_pool:lease() of
+  logger:debug("Count = ~p~n", [Count + 1]),
+  case asset_pool:lease(Pid) of
     {ok, Asset} ->
-      % io:format("i", []),
-      spawn(fun() -> process_now(Request, Asset) end),
-      State2;
+      logger:debug("Leased asset for pool ~p~n", [Pid]),
+      spawn(fun() -> process_now(Pid, Request, Asset) end),
+      finish(Priority, Q2, State2);
     empty ->
-      % io:format("q", []),
-      Pending2 = queue:in(Request, State#state.pending),
-      State2#state{pending = Pending2}
+      State
   end.
 
-process_now(Request, Asset) ->
+process_now(Pid, Request, Asset) ->
   try unsafe_process_now(Request, Asset) of
     _AnyResponse -> ok
   catch
-    _AnyError -> ok
+    _AnyClass:_AnyError -> ok
   after
-    asset_pool:return(Asset),
-    ernie_server:asset_freed(),
+    asset_pool:return(Pid, Asset),
+    ernie_server:kick(),
     gen_tcp:close(Request#request.sock)
   end.
 

data/elib/ernie_server_app.erl

@@ -8,8 +8,7 @@ boot() ->
 
 start(_Type, _Args) ->
   logger_sup:start_link(),
-  ernie_server_sup:start_link(),
-  asset_pool_sup:start_link().
+  ernie_server_sup:start_link().
 
 stop(_State) ->
   ok.

data/elib/ernie_server_sup.erl

@@ -14,6 +14,9 @@ init([]) ->
       ok = file:write_file(Location, list_to_binary(Pid));
     undefined -> ok
   end,
+  {ok, Config} = application:get_env(ernie_server_app, config),
+  {ok, Configs} = ernie_config:load(Config),
+  io:format("~p~n", [Configs]),
   {ok, {{one_for_one, 1, 60},
-    [{ernie_server, {ernie_server, start_link, [[Port]]},
+    [{ernie_server, {ernie_server, start_link, [[Port, Configs]]},
     permanent, brutal_kill, worker, [ernie_server]}]}}.

data/ernie.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ernie}
-  s.version = "1.3.0"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tom Preston-Werner"]
-  s.date = %q{2009-11-30}
+  s.date = %q{2010-02-16}
   s.default_executable = %q{ernie}
   s.email = %q{tom@mojombo.com}
   s.executables = ["ernie"]
@@ -27,9 +27,15 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION.yml",
      "bin/ernie",
+     "contrib/ebench.erl",
      "ebin/ernie_server_app.app",
      "elib/asset_pool.erl",
      "elib/asset_pool_sup.erl",
+     "elib/bert.erl",
+     "elib/ernie.hrl",
+     "elib/ernie_admin.erl",
+     "elib/ernie_config.erl",
+     "elib/ernie_native.erl",
      "elib/ernie_server.erl",
      "elib/ernie_server_app.erl",
      "elib/ernie_server_sup.erl",
@@ -37,16 +43,19 @@ Gem::Specification.new do |s|
      "elib/logger_sup.erl",
      "elib/port_wrapper.erl",
      "ernie.gemspec",
-     "examples/dsl.rb",
-     "examples/expose.rb",
+     "examples/example.cfg",
+     "examples/ext.erl",
+     "examples/ext.rb",
+     "examples/nat.erl",
      "ext/Makefile",
      "ext/extconf.rb",
      "lib/ernie.rb",
      "test/ernie_server_test.rb",
      "test/ernie_test.rb",
-     "test/handler.rb",
      "test/helper.rb",
-     "test/load.rb"
+     "test/load.rb",
+     "test/sample/ext.rb",
+     "test/sample/sample.cfg"
   ]
   s.homepage = %q{http://github.com/mojombo/ernie}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -56,11 +65,10 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/ernie_server_test.rb",
      "test/ernie_test.rb",
-     "test/handler.rb",
      "test/helper.rb",
      "test/load.rb",
-     "examples/dsl.rb",
-     "examples/expose.rb"
+     "test/sample/ext.rb",
+     "examples/ext.rb"
   ]
 
   if s.respond_to? :specification_version then

data/examples/example.cfg

@@ -0,0 +1,12 @@
+[{module, ext},
+ {type, native},
+ {codepaths, ["examples"]}].
+
+[{module, ext},
+ {type, external},
+ {command, "ruby examples/ext.rb"},
+ {count, 2}].
+
+[{module, nat},
+ {type, native},
+ {codepaths, ["examples"]}].

data/examples/ext.erl

@@ -0,0 +1,8 @@
+-module(ext).
+-export([shadow_pred/1, shadow/1]).
+
+shadow_pred(X) ->
+  X > 10.
+
+shadow(_X) ->
+  <<"erlang">>.

data/examples/{expose.rb → ext.rb}

@@ -1,12 +1,24 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'ernie'
 
-module Test
+module Ext
   # Add two numbers together
   def add(a, b)
     a + b
   end
 
+  def fib(n)
+    if n == 0 || n == 1
+      1
+    else
+      fib(n - 1) + fib(n - 2)
+    end
+  end
+
+  def shadow(x)
+    "ruby"
+  end
+
   # Return the given number of bytes
   def bytes(n)
     'x' * n
@@ -24,4 +36,4 @@ module Test
   end
 end
 
-Ernie.expose(:test, Test)
+Ernie.expose(:ext, Ext)

data/examples/nat.erl

@@ -0,0 +1,12 @@
+-module(nat).
+-export([add/2, fib/1, die/1]).
+
+add(A, B) ->
+  A + B.
+
+fib(0) -> 1;
+fib(1) -> 1;
+fib(N) when N > 1 -> fib(N - 1) + fib(N - 2).
+
+die(X) ->
+  X = 10.

data/lib/ernie.rb

@@ -11,7 +11,7 @@ class Ernie
   self.mods = {}
   self.current_mod = nil
   self.log = Logger.new(STDOUT)
-  self.log.level = Logger::INFO
+  self.log.level = Logger::FATAL
   self.auto_start = true
 
   # Record a module.
@@ -189,14 +189,6 @@ end
 
 # Root level calls
 
-def mod(name, &block)
-  Ernie.mod(name, block)
-end
-
-def fun(name, &block)
-  Ernie.fun(name, block)
-end
-
 def logfile(name)
   Ernie.logfile(name)
 end

data/test/ernie_server_test.rb

@@ -5,14 +5,14 @@ PORT = 27118
 class ErnieServerTest < Test::Unit::TestCase
   context "An Ernie Server" do
     setup do
-      `#{ERNIE_ROOT}/bin/ernie -h #{ERNIE_ROOT}/test/handler.rb \
+      `#{ERNIE_ROOT}/bin/ernie -c #{ERNIE_ROOT}/test/sample/sample.cfg \
                                -P /tmp/ernie.pid \
                                -p #{PORT} \
                                -d`
       @svc = BERTRPC::Service.new('localhost', PORT)
       loop do
         begin
-          @svc.call.test.zeronary
+          @svc.call.ext.zeronary
           break
         rescue Object => e
           sleep 0.1
@@ -22,23 +22,23 @@ class ErnieServerTest < Test::Unit::TestCase
 
     context "call" do
       should "handle zeronary" do
-        assert_equal :foo, @svc.call.test.zeronary
+        assert_equal :foo, @svc.call.ext.zeronary
       end
 
       should "handle unary" do
-        assert_equal 5, @svc.call.test.unary(5)
+        assert_equal 5, @svc.call.ext.unary(5)
       end
 
       should "handle binary" do
-        assert_equal 7, @svc.call.test.binary(5, 2)
+        assert_equal 7, @svc.call.ext.binary(5, 2)
       end
 
       should "handle ternary" do
-        assert_equal 10, @svc.call.test.ternary(5, 2, 3)
+        assert_equal 10, @svc.call.ext.ternary(5, 2, 3)
       end
 
       should "handle massive binaries" do
-        assert_equal 8 * 1024 * 1024, @svc.call.test.big(8 * 1024 * 1024).size
+        assert_equal 8 * 1024 * 1024, @svc.call.ext.big(8 * 1024 * 1024).size
       end
 
       should "get an error on missing module" do
@@ -52,10 +52,10 @@ class ErnieServerTest < Test::Unit::TestCase
 
       should "get an error on missing function" do
         begin
-          @svc.call.test.mcfail(:fail)
+          @svc.call.ext.mcfail(:fail)
           fail "Expected a BERTRPC::ServerError"
         rescue BERTRPC::ServerError => e
-          assert_equal "No such function 'test:mcfail'", e.message
+          assert_equal "No such function 'ext:mcfail'", e.message
         end
       end
     end
@@ -63,9 +63,9 @@ class ErnieServerTest < Test::Unit::TestCase
     context "cast" do
       should "be received and return immediately" do
         t0 = Time.now
-        assert_equal nil, @svc.cast.test.set_state(7)
+        assert_equal nil, @svc.cast.ext.set_state(7)
         assert Time.now - t0 < 1
-        assert_equal 7, @svc.call.test.get_state
+        assert_equal 7, @svc.call.ext.get_state
       end
     end
 

data/test/ernie_test.rb

@@ -1,50 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
 class ErnieTest < Test::Unit::TestCase
-  context "mod" do
-    should "yield to the block" do
-      called = false
-      mod(:foo) { called = true }
-      assert called, "mod did not yield to the block"
-    end
-
-    should "add a mod to the mods hash" do
-      mod(:foo) { }
-      assert Ernie.mods[:foo]
-      assert Ernie.mods[:foo].instance_of?(Ernie::Mod)
-    end
-
-    should "overwrite previous mod with the same name" do
-      first_mod_object, second_mod_object = nil, nil
-      mod(:foo) { first_mod_object = Ernie.current_mod }
-      mod(:foo) { second_mod_object = Ernie.current_mod }
-      assert_not_same second_mod_object, first_mod_object
-    end
-
-    should "set the mod's name" do
-      mod(:foo) { }
-      assert_equal :foo, Ernie.mods[:foo].name
-    end
-  end
-
-  context "fun" do
-    should "add a fun to the funs hash of the mod" do
-      mod(:foo) { fun(:bar) { } }
-      assert Ernie.mods[:foo].funs[:bar]
-    end
-
-    should "dispatch to a fun" do
-      mod(:foo) { fun(:echo) { |arg| arg } }
-      assert 'hello', Ernie.dispatch(:foo, :echo, 'hello')
-    end
-
-    should "fail when no block is provided" do
-      assert_raises(TypeError) do
-        mod(:foo) { fun(:bar) }
-      end
-    end
-  end
-
   module TestExposingModule
     def foo
     end