remote_logger 0.0.3 → 0.0.4

data/HISTORY

@@ -9,3 +9,7 @@
 == 0.0.3 / 2010-09-06
 
 * Gemspec fixed
+
+== 0.0.4 / 2010-09-06
+
+* Procedures converted into classes

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/remote_logger/drb_logger.rb

@@ -0,0 +1,30 @@
+module RemoteLogger
+
+  # Subclass of RemoteLogger::Logger communicating via DRb protocol
+  class DrbLogger < RemoteLogger::Logger
+
+    def self.start(name = LOGGER_NAME, options = {})
+      # Adding some security (disable remote eval)
+      $SAFE = 1
+
+      # Creating logger instance
+      logger = new options
+
+      # Raising new RingyDingy service
+      logger.info "#{name}: Initializing service..." if options[:verbose]
+      DRb.start_service(options[:uri]||DRB_URI, logger)
+      logger.info "#{name}: Service started" if options[:verbose]
+
+      DRb.thread.join
+
+      # Never reaches this point...
+      logger.info "#{name}: Service finished" if options[:verbose]
+    end
+
+    def self.find(name = LOGGER_NAME, options = {})
+      DRb.start_service
+      # Connecting to Logger
+      DRbObject.new_with_uri(options[:uri]||DRB_URI)
+    end
+  end
+end

data/lib/remote_logger/logger.rb

@@ -0,0 +1,63 @@
+#encoding: UTF-8
+
+# TODO: Set up ACL, SSL and other security stuff
+module RemoteLogger
+  DRB_URI = 'druby://127.0.0.1:61626'
+  LOGGER_NAME = 'RemoteLogger'
+  # Default service/logger name - used by Ring or retrieved via Log4R::Logger[LOGGER_NAME]
+  FILE_NAME = 'remote.log'
+  # File name of log file
+  FILE_ENCODING = 'CP1251:UTF-8'
+  # Encoding pair of log file ('File external:Ruby internal')
+  STDOUT_ENCODING = 'CP866:UTF-8'
+  # Encoding pair of stdout ('Stdout external:Ruby internal')
+  PATTERN = '%1.1l %d - %m'
+  # Log entry pattern
+  DATE_PATTERN = '%Y-%m-%d %H:%M:%S.%3N'
+
+  # A subclass of Log4r::Logger pre-configured with specific logging settings
+  class Logger < Log4r::Logger
+    include Log4r
+
+    # Creates new remote logger. The following options are available:
+    #
+    # <tt>:name</tt>:: Service/logger name - default 'RemoteLogger'
+    # <tt>:outputters</tt>:: Replace outputters (should be Log4r::Outputter subclasses) - default [log file, stdout]
+    # <tt>:file_name</tt>:: Log file name - default 'remote.log'
+    # <tt>:file_encoding</tt>:: Log file encoding - default FILE_ENCODING (Windows Cyrillic)
+    # <tt>:stdout_encoding</tt>:: Stdout encoding - default STDOUT_ENCODING (DOS/IBM Cyrillic)
+    # <tt>:replace</tt>:: Replacement for undefined conversion chars - default '?'
+    # <tt>:pattern</tt>:: Log message pattern - default PATTERN
+    # <tt>:date_pattern</tt>:: Timestamp pattern - default DATE_PATTERN
+    # <tt>:trunc</tt>:: Truncate (rewrite) log file upon creation  - default false (append to file)
+    # <tt>:verbose</tt>:: Log all internal messages of RemoteLogger - default false (do not log logger-specific messages)
+    #
+    def initialize options = {}
+      # define outputters: http://log4r.sourceforge.net/rdoc/files/log4r/outputter/outputter_rb.html
+      if options[:outputters]
+        outputters = options[:outputters]
+      else
+        # specify log message format: http://log4r.sourceforge.net/rdoc/files/log4r/formatter/patternformatter_rb.html
+        format = PatternFormatter.new :pattern => options[:pattern]||PATTERN,
+                                      :date_pattern => options[:date_pattern]||DATE_PATTERN
+
+        # Set up IO streams with correct transcoding and conversion options: log file and (Windows) console
+        conversion = {:undef=>:replace, :replace=>options[:replace]||'?'}
+        file = File.new(                                  options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
+                (options[:file_encoding]||FILE_ENCODING), conversion)
+        $stdout.set_encoding(options[:stdout_encoding]||STDOUT_ENCODING, conversion)
+
+        outputters = [StdoutOutputter.new('console', :formatter => format),
+                      IOOutputter.new('file', file, :formatter => format)]
+#   file_o = FileOutputter.new 'file', :filename => 'remote.log', :trunc => false, :formatter => format # wrong encoding
+#   err_o = StderrOutputter.new 'error', :formatter => format # just in case
+      end
+
+      # create new logger named LOG_NAME
+      super(options[:name]||LOGGER_NAME).tap do |logger|
+        logger.outputters = outputters
+        logger.info "#{name}: Logger created" if options[:verbose]
+      end
+    end
+  end
+end

data/lib/remote_logger/ringy_logger.rb

@@ -0,0 +1,37 @@
+module RemoteLogger
+
+  # Subclass of RemoteLogger::Logger communicating via DRb protocol
+  class RingyLogger < Logger
+
+    def self.start(name = LOGGER_NAME, options = {})
+      # Adding some security (disable remote eval)
+      $SAFE = 1
+
+      # Creating logger instance
+      logger = RemoteLogger::Logger.new options
+
+      DRb.start_service
+
+      # Raising new RingyDingy service
+      logger.info "#{name}: Initializing service..." if options[:verbose]
+      RingyDingy.new(logger, name.to_sym).run
+      logger.info "#{name}: Service started" if options[:verbose]
+
+      DRb.thread.join
+
+      # Never reaches this point...
+      logger.info "#{name}: Service finished" if options[:verbose]
+    end
+
+    def self.find(name = LOGGER_NAME, options = {})
+      DRb.start_service
+
+      # Connecting to Ring server
+      ring_server = Rinda::RingFinger.primary
+
+      # Requesting logger service by name
+      service = ring_server.read [:name, name.to_sym, nil, nil]
+      service[2]
+    end
+  end
+end

data/lib/remote_logger.rb

@@ -25,5 +25,5 @@ end  # module RemoteLogger
 
 # Require all ruby source files located under directory lib/remote_logger
 # If you need files in specific order, you should specify it here before the glob
-RemoteLogger.require_libs %W[**/*]
+RemoteLogger.require_libs %W[logger **/*]
 

data/spec/remote_logger/drb_logger_spec.rb

@@ -0,0 +1,19 @@
+#encoding: UTF-8
+require_relative '../spec_helper'
+require_relative 'shared_spec'
+
+module RemoteLoggerTest
+  describe RemoteLogger::DrbLogger do
+    spec { use { include RemoteLogger } }
+
+    context 'creating Drb logger' do
+      spec { pending; use { RemoteLogger.start_drb_logger(name = 'RemoteLogger', options = {}) } }
+
+      it_should_behave_like 'Logger'
+
+      it 'instantiates drb logger service'
+
+    end
+  end
+end
+

data/spec/remote_logger/logger_spec.rb

@@ -0,0 +1,12 @@
+#encoding: UTF-8
+require_relative '../spec_helper'
+require_relative 'shared_spec'
+
+module RemoteLoggerTest
+
+  describe RemoteLogger::Logger do
+
+    it_should_behave_like 'Logger'
+
+  end
+end

data/spec/remote_logger/shared_spec.rb

@@ -0,0 +1,131 @@
+#encoding: UTF-8
+require_relative '../spec_helper'
+
+module RemoteLoggerTest
+
+  shared_examples_for 'Logger' do
+    before(:each) do
+      File.stub!(:new) { |name, mode, opts| @logfile_mock = StringIO.new('', mode) }
+    end
+
+    context ' by default' do
+      it 'creates a subclass of Log4r logger with default name "RemoteLogger"' do
+        logger = described_class.new
+        logger.should be_a_kind_of Log4r::Logger
+        logger.should == Log4r::Logger['RemoteLogger']
+        logger.should == RemoteLogger::Logger['RemoteLogger']
+      end
+
+      it 'outputs log messages to IOstream(file) and stdout simultaneously' do
+        outputters = described_class.new.outputters
+        outputters.should have(2).outputters
+        outputters.first.should be_an_instance_of Log4r::StdoutOutputter
+        outputters.last.should be_an_instance_of Log4r::IOOutputter
+      end
+
+      it 'appends to logfile "remote.log" with Windows-1251(Cyrillic) encoding' do
+        File.should_receive(:new) do |filename, mode, options|
+          filename.should == "remote.log"
+          mode.should =~ /^a:/
+          mode.should =~ /(CP|cp)1251:/
+        end
+        logger = described_class.new
+      end
+
+      it 'writes to stdout with IBM-866(DOS-Cyrillic) encoding' do
+        $stdout.should_receive(:set_encoding).with(/(CP|cp)866:/, hash_including(:undef))
+        logger = described_class.new
+      end
+
+      it 'logs string messages using default pattern' do
+        logger = described_class.new
+        logger_should_log 'I %Y-%m-%d %H:%M:\d{2}.\d{3} - My message\n'
+        logger.info 'My message'
+      end
+
+      it 'does not log logger creation announcement' do
+        pending 'both @logfile_mock creation and announcement happens in sequence, impossible to set expectations'
+        logger_should_not_log 'Logger created'
+        logger = described_class.new
+      end
+
+      it 'replaces illegal chars in output codepages with ?' do
+        pending 'Impossible to test without real files, since StringIO does not support :undef option'
+        logger_should_log 'I %Y-%m-%d %H:%M:\d{2}.\d{3} - My ?? message\n'
+        logger = described_class.new
+        logger.info 'My 開始 message'
+      end
+    end
+
+    context 'with options' do
+      it 'accepts logger name with :name option' do
+        logger = described_class.new :name=>'MyLogger'
+        logger.should == Log4r::Logger['MyLogger']
+        logger.should == RemoteLogger::Logger['MyLogger']
+      end
+
+      it 'accepts logfile name with :file_name option' do
+        File.should_receive(:new).with('my_name.log', anything, anything)
+        logger = described_class.new :file_name=>'my_name.log'
+      end
+
+      it 'accepts custom log pattern with :pattern option' do
+        logger = described_class.new :pattern=>'%d %l %7.7m'
+        logger_should_log '%Y-%m-%d %H:%M:\d{2}.\d{3} INFO My mess\n'
+        logger.info 'My message'
+      end
+
+      it 'accepts custom date pattern with :date_pattern option' do
+        logger = described_class.new :date_pattern=>'%m/%d/%y'
+        logger_should_log 'I %m/%d/%y - My message\n'
+        logger.info 'My message'
+      end
+
+      it 'accepts custom file encoding with :file_encoding option' do
+        File.should_receive(:new).with(anything, /^a:CP866/, anything)
+        logger = described_class.new :file_encoding=>'CP866'
+      end
+
+      it 'accepts custom stdout encoding with :stdout_encoding option' do
+        $stdout.should_receive(:set_encoding).with(/CP1251/, hash_including(:undef))
+        logger = described_class.new :stdout_encoding=>'CP1251'
+      end
+
+      it 'accepts custom outputters with :outputters option, replacing default outputters' do
+        out_string = StringIO.new
+        $stdout.should_not_receive(:set_encoding)
+        File.should_not_receive(:new)
+        logger = described_class.new :outputters=>Log4r::IOOutputter.new('errors', out_string)
+        $stdout.should_not_receive(:print)
+        out_string.should_receive(:print).with " INFO RemoteLogger: My message\n"
+        logger.info 'My message'
+      end
+
+      it 'rewrites logfile with :trunc option' do
+        File.should_receive(:new).with(anything, /^w:/, anything)
+#         File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
+#                   (options[:file_encoding]||FILE_ENCODING), :undef => options[:undef]||:replace)
+        logger = described_class.new( trunc: true)
+      end
+
+      it 'specifies conversion replacement char with :replace option' do
+        pending 'Impossible to test without real files, since StringIO does not support :undef option'
+        File.should_receive(:new).with(anything, anything, hash_including(:replace))
+#         File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
+#                   (options[:file_encoding]||FILE_ENCODING), :undef => options[:undef]||:replace)
+        logger = described_class.new
+        #:replace=>'-'
+        logger_should_log '%Y-%m-%d %H:%M:\d{2}.\d{3} INFO My -- message\n'
+        logger.info 'My 開始 message'
+        p @logfile_mock
+      end
+
+      it 'logs logger creation announcement with :verbose option' do
+        pending 'both @logfile_mock creation and announcement happens in sequence, impossible to set expectations'
+        logger_should_log 'Logger created'
+        logger = described_class.new( verbose: true )
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -45,4 +45,11 @@ module RemoteLoggerTest
     @logfile_mock.should_receive(:print).with(Regexp.new(formatted_message))
     $stdout.should_receive(:print).with(Regexp.new(formatted_message))
   end
+
+  def logger_should_not_log message
+    formatted_message = Time.now.strftime message
+    @logfile_mock.should_not_receive(:print).with(Regexp.new(formatted_message))
+    $stdout.should_not_receive(:print).with(Regexp.new(formatted_message))
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: remote_logger
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - arvicco
@@ -92,10 +92,14 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - bin/remote_logger
-- lib/remote_logger/remote_logger.rb
+- lib/remote_logger/drb_logger.rb
+- lib/remote_logger/logger.rb
+- lib/remote_logger/ringy_logger.rb
 - lib/remote_logger.rb
 - lib/version.rb
-- spec/remote_logger/remote_logger_spec.rb
+- spec/remote_logger/drb_logger_spec.rb
+- spec/remote_logger/logger_spec.rb
+- spec/remote_logger/shared_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - features/remote_logger.feature
@@ -153,6 +157,8 @@ signing_key:
 specification_version: 3
 summary: Client/server for remote logger using multiple communication methods
 test_files: 
-- spec/remote_logger/remote_logger_spec.rb
+- spec/remote_logger/drb_logger_spec.rb
+- spec/remote_logger/logger_spec.rb
+- spec/remote_logger/shared_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb

data/lib/remote_logger/remote_logger.rb

@@ -1,104 +0,0 @@
-#encoding: UTF-8
-# TODO: Set up ACL, SSL and other security stuff
-module RemoteLogger
-  include Log4r
-
-  DRB_URI = 'druby://127.0.0.1:61626'
-  LOGGER_NAME = 'RemoteLogger' # Default service/logger name - used by Ring or retrieved via Log4R::Logger[LOGGER_NAME]
-  FILE_NAME = 'remote.log' # File name of log file
-  FILE_ENCODING = 'CP1251:UTF-8' # Encoding pair of log file ('File external:Ruby internal')
-  STDOUT_ENCODING = 'CP866:UTF-8' # Encoding pair of stdout ('Stdout external:Ruby internal')
-  PATTERN = '%1.1l %d - %m' # Log entry pattern
-  DATE_PATTERN = '%Y-%m-%d %H:%M:%S.%3N'
-
-  # Creates a new Log4r logger. The following options are available:
-  #
-  # <tt>:name</tt>:: Service/logger name - default 'RemoteLogger'
-  # <tt>:outputters</tt>:: Replace outputters (should be Log4r::Outputter subclasses) - default [log file, stdout]
-  # <tt>:file_name</tt>:: Log file name - default 'remote.log'
-  # <tt>:file_encoding</tt>:: Log file encoding - default FILE_ENCODING (Windows Cyrillic)
-  # <tt>:stdout_encoding</tt>:: Stdout encoding - default STDOUT_ENCODING (DOS/IBM Cyrillic)
-  # <tt>:replace</tt>:: Replacement for undefined conversion chars - default '?'
-  # <tt>:pattern</tt>:: Log message pattern - default PATTERN
-  # <tt>:date_pattern</tt>:: Timestamp pattern - default DATE_PATTERN
-  # <tt>:trunc</tt>:: Truncate (rewrite) log file upon creation  - default false (append to file)
-  # <tt>:verbose</tt>:: Log all internal messages of RemoteLogger - default false (do not log logger-specific messages)
-  #
-  def self.create_logger options = {}
-    # define outputters: http://log4r.sourceforge.net/rdoc/files/log4r/outputter/outputter_rb.html
-    if options[:outputters]
-      outputters = options[:outputters]
-    else
-      # specify log message format: http://log4r.sourceforge.net/rdoc/files/log4r/formatter/patternformatter_rb.html
-      format = PatternFormatter.new :pattern => options[:pattern]||PATTERN,
-                                    :date_pattern => options[:date_pattern]||DATE_PATTERN
-
-      # Set up IO streams with correct transcoding and conversion options: log file and (Windows) console
-      conversion = {:undef=>:replace, :replace=>options[:replace]||'?'}
-      file = File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
-              (options[:file_encoding]||FILE_ENCODING), conversion )
-      $stdout.set_encoding(options[:stdout_encoding]||STDOUT_ENCODING, conversion)
-
-      outputters = [StdoutOutputter.new('console', :formatter => format),
-                    IOOutputter.new('file', file, :formatter => format) ]
-#   file_o = FileOutputter.new 'file', :filename => 'remote.log', :trunc => false, :formatter => format # wrong encoding
-#   err_o = StderrOutputter.new 'error', :formatter => format # just in case
-    end
-
-    # create new logger named LOG_NAME
-    Logger.new(options[:name]||LOGGER_NAME).tap do |logger|
-      logger.outputters = outputters
-      logger.info "#{name}: Logger created" if options[:verbose]
-    end
-  end
-
-  def self.start_ringy_logger(name = LOGGER_NAME, options = {})
-    # Adding some security (disable remote eval)
-    $SAFE = 1
-
-    # Creating logger instance
-    logger = create_logger options
-
-    DRb.start_service
-
-    # Raising new RingyDingy service
-    logger.info "#{name}: Initializing service..." if options[:verbose]
-    RingyDingy.new(logger, name.to_sym).run
-    logger.info "#{name}: Service started" if options[:verbose]
-
-    DRb.thread.join
-    logger.info "#{name}: Service finished" if options[:verbose]
-  end
-
-  def self.find_ringy_logger(name = LOGGER_NAME, options = {})
-    DRb.start_service
-    # Connecting to Logger
-    ring_server = Rinda::RingFinger.primary
-    service = ring_server.read [:name, name.to_sym, nil, nil]
-    service[2]
-  end
-
-  def self.start_drb_logger(name = LOGGER_NAME, options = {})
-    # Adding some security (disable remote eval)
-    $SAFE = 1
-
-    # Creating logger instance
-    logger = create_logger options
-
-    # Raising new RingyDingy service
-    logger.info "#{name}: Initializing service..." if options[:verbose]
-    DRb.start_service(options[:uri]||DRB_URI, logger)
-    logger.info "#{name}: Service started" if options[:verbose]
-
-    DRb.thread.join
-    logger.info "#{name}: Service finished" if options[:verbose]
-  end
-
-  def self.find_drb_logger(name = LOGGER_NAME, options = {})
-    DRb.start_service
-    # Connecting to Logger
-    log = DRbObject.new_with_uri(options[:uri]||DRB_URI)
-  end
-
-
-end

data/spec/remote_logger/remote_logger_spec.rb

@@ -1,132 +0,0 @@
-#encoding: UTF-8
-require_relative '../spec_helper'
-
-module RemoteLoggerTest
-  describe RemoteLogger do
-    before(:each) do
-      File.stub!(:new) {|name, mode, opts| @logfile_mock = StringIO.new('', mode) }
-    end
-
-    spec {use { include RemoteLogger}}
-
-    shared_examples_for 'Log4r proxy' do
-      context ' by default' do
-        it 'creates Log4r logger with default name "RemoteLogger"' do
-          logger = RemoteLogger.create_logger
-          logger.should be_an_instance_of Log4r::Logger
-          logger.should == Log4r::Logger['RemoteLogger']
-          logger.should == RemoteLogger::Logger['RemoteLogger']
-        end
-
-        it 'outputs log messages to IOstream(file) and stdout simultaneously' do
-          outputters = RemoteLogger.create_logger.outputters
-          outputters.should have(2).outputters
-          outputters.first.should be_an_instance_of Log4r::StdoutOutputter
-          outputters.last.should be_an_instance_of Log4r::IOOutputter
-        end
-
-        it 'appends to logfile "remote.log" with Windows-1251(Cyrillic) encoding' do
-          File.should_receive(:new) do |filename, mode, options|
-            filename.should == "remote.log"
-            mode.should =~ /^a:/
-            mode.should =~ /(CP|cp)1251:/
-          end
-          logger = RemoteLogger.create_logger
-        end
-
-        it 'writes to stdout with IBM-866(DOS-Cyrillic) encoding' do
-          $stdout.should_receive(:set_encoding).with(/(CP|cp)866:/, hash_including(:undef))
-          logger = RemoteLogger.create_logger
-        end
-
-        it 'logs string messages using default pattern' do
-          logger = RemoteLogger.create_logger
-          logger_should_log 'I %Y-%m-%d %H:%M:\d{2}.\d{3} - My message\n'
-          logger.info 'My message'
-        end
-
-        it 'logs logger creation announcement'
-
-        it 'replaces illegal chars in output codepages with ?' do
-          pending 'Impossible to test without real files'
-          logger_should_log 'I %Y-%m-%d %H:%M:\d{2}.\d{3} - My ? message\n'
-          logger = RemoteLogger.create_logger
-          logger.info 'My 昔 message'
-        end
-      end
-
-      context 'with options' do
-        it 'accepts logger name with :name option' do
-          logger = RemoteLogger.create_logger :name=>'MyLogger'
-          logger.should == Log4r::Logger['MyLogger']
-          logger.should == RemoteLogger::Logger['MyLogger']
-        end
-
-        it 'accepts logfile name with :file_name option' do
-          File.should_receive(:new).with('my_name.log', anything, anything)
-          logger = RemoteLogger.create_logger :file_name=>'my_name.log'
-        end
-
-        it 'accepts custom log pattern with :pattern option' do
-          logger = RemoteLogger.create_logger :pattern=>'%d %l %7.7m'
-          logger_should_log '%Y-%m-%d %H:%M:\d{2}.\d{3} INFO My mess\n'
-          logger.info 'My message'
-        end
-
-        it 'accepts custom date pattern with :date_pattern option' do
-          logger = RemoteLogger.create_logger :date_pattern=>'%m/%d/%y'
-          logger_should_log 'I %m/%d/%y - My message\n'
-          logger.info 'My message'
-        end
-
-        it 'accepts custom file encoding with :file_encoding option' do
-          File.should_receive(:new).with(anything, /^a:CP866/, anything)
-          logger = RemoteLogger.create_logger :file_encoding=>'CP866'
-        end
-
-        it 'accepts custom stdout encoding with :stdout_encoding option' do
-          $stdout.should_receive(:set_encoding).with(/CP1251/, hash_including(:undef))
-          logger = RemoteLogger.create_logger :stdout_encoding=>'CP1251'
-        end
-
-        it 'accepts custom outputters with :outputters option, replacing default outputters' do
-          out_string = StringIO.new
-          $stdout.should_not_receive(:set_encoding)
-          File.should_not_receive(:new)
-          logger = RemoteLogger.create_logger :outputters=>Log4r::IOOutputter.new('errors', out_string)
-          $stdout.should_not_receive(:print)
-          out_string.should_receive(:print).with " INFO RemoteLogger: My message\n"
-          logger.info 'My message'
-        end
-
-        it 'rewrites logfile with :trunc option' do
-          File.should_receive(:new).with(anything, /^w:/, anything)
-#         File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
-#                   (options[:file_encoding]||FILE_ENCODING), :undef => options[:undef]||:replace)
-          logger = RemoteLogger.create_logger :trunc=>true
-        end
-
-        it 'specifies conversion replacement char with :replace option' do
-          pending 'Impossible to test without real files'
-          File.should_receive(:new).with(anything, anything, hash_including(:replace))
-#         File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
-#                   (options[:file_encoding]||FILE_ENCODING), :undef => options[:undef]||:replace)
-          logger = RemoteLogger.create_logger #:replace=>'-'
-          logger_should_log '%Y-%m-%d %H:%M:\d{2}.\d{3} INFO My - message\n'
-          logger.info 'My 昔 message'
-        end
-
-        it 'skips logger creation announcement with :silent option'
-       end
-    end
-
-    context 'creating Drb logger' do
-      spec{ pending; use{  RemoteLogger.start_drb_logger(name = 'RemoteLogger', options = {})}}
-      it_should_behave_like 'Log4r proxy'
-
-      it 'instantiates drb logger service' do
-
-      end
-    end
-  end
-end