macruby-asl-logger 0.1.0

data/LICENSE

@@ -0,0 +1,55 @@
+Copyright (c) <2010> Eloy Duran, <eloy.de.enige@gmail.com>
+
+This software is available under the Ruby license:
+
+===============================================================================
+
+You can redistribute it and/or modify it under either the terms of the GPL, or
+the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise make them
+          Freely Available, such as by posting said modifications to Usenet or
+          an equivalent medium, or by allowing the author to include your
+          modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict with
+          standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable form,
+      provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+          together with instructions (in the manual page or equivalent) on
+          where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of the
+          software.
+
+       c) give non-standard executables non-standard names, with instructions
+          on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+      software (possibly commercial).
+
+  5. The scripts and library files supplied as input to or produced as output
+     from the software do not automatically fall under the copyright of the
+     software, but belong to whomever generated them, and may be sold
+     commercially, and may be aggregated with this software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+     WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

data/README

@@ -0,0 +1,9 @@
+Currently a very naive implementation, which might be updated to resemble the
+existing Ruby logger API more closely.
+
+Also, this release (0.1.0) probably comes packed with bugs! :P This should be
+considered a pre-release, but I will *not* use those stupid pre-release gem
+version thingies.
+
+This software is available under the Ruby license. (See LICENSE for details.)
+Copyright (c) <2010> Eloy Duran, <eloy.de.enige@gmail.com>

data/Rakefile

@@ -0,0 +1,32 @@
+desc "Build the ext"
+task :build do
+  sh "cd ext && macruby extconf.rb && make"
+end
+
+desc "Clean"
+task :clean do
+  rm "ext/Makefile"
+  rm "ext/logger.o"
+  rm "ext/logger.bundle"
+end
+
+desc "Run the specs"
+task :spec do
+  sh "macruby -r #{FileList['spec/*_spec.rb'].join(' -r ')} -e ''"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "macruby-asl-logger"
+    gemspec.summary = gemspec.description = "A MacRuby wrapper of the Apple System Log facility"
+    gemspec.homepage = "http://github.com/alloy/macruby-asl-logger"
+    
+    gemspec.authors = ["Eloy Duran"]
+    gemspec.email = "eloy.de.enige@gmail.com"
+    
+    gemspec.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+    gemspec.files.delete '.gitignore'
+  end
+rescue LoadError
+end

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+$CFLAGS << ' -std=c99'
+create_makefile('logger')

data/ext/logger.c

@@ -0,0 +1,128 @@
+#include <fcntl.h>
+#include <asl.h>
+
+#include "ruby/ruby.h"
+#include "ruby/io.h"
+
+VALUE cLogger;
+
+struct mr_logger {
+  aslclient asl_client;
+  VALUE file_descriptor;
+  // VALUE file_descriptors;
+};
+
+uint32_t LoggerDefaultASLOptions = ASL_OPT_NO_DELAY | ASL_OPT_STDERR | ASL_OPT_NO_REMOTE;
+
+static VALUE
+mr_logger_allocate(VALUE klass, SEL sel)
+{
+    VALUE obj;
+    struct mr_logger *logger;
+    
+    obj = Data_Make_Struct(klass, struct mr_logger, NULL, NULL, logger);
+    // logger->file_descriptors = rb_ary_new();
+    
+    return obj;
+}
+
+// so initialize *always* has to take variadic args?
+static VALUE
+mr_logger_initialize(VALUE self, SEL sel, int argc, VALUE *argv)
+{
+    if (argc != 1) {
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+    }
+    
+    struct mr_logger *logger;
+    Data_Get_Struct(self, struct mr_logger, logger);
+    
+    // If no facility is specified, use "com.apple.console"
+    // TODO: add custom facility
+    logger->asl_client = asl_open(NULL, "com.apple.console", LoggerDefaultASLOptions);
+    
+    VALUE io = argv[0];
+    if (rb_respond_to(io, rb_intern("write")) == Qfalse || rb_respond_to(io, rb_intern("close")) == Qfalse) {
+      // TODO: currently I just assume it's a string if it's not an IO object
+      const char *fname = rb_str_cstr(io);
+      int mode = O_WRONLY | O_APPEND;
+      int fd = open(fname, mode);
+      io = rb_io_fdopen(fd, mode, fname);
+    }
+    logger->file_descriptor = io;
+    
+    if (asl_add_log_file(logger->asl_client, ExtractIOStruct(io)->fd) == 0) {
+      // printf("success!\n");
+    }
+    
+    return self;
+}
+
+void
+mr_logger_close(VALUE self, SEL sel)
+{
+  struct mr_logger *logger;
+  Data_Get_Struct(self, struct mr_logger, logger);
+  
+  rb_io_close(logger->file_descriptor);
+  asl_close(logger->asl_client);
+}
+
+static void
+logger_add(VALUE self, int level, VALUE text)
+{
+  struct mr_logger *logger;
+  Data_Get_Struct(self, struct mr_logger, logger);
+  
+  // TODO: good way to check if it's open
+  if (ExtractIOStruct(logger->file_descriptor)->write_fd != -1) {
+    aslmsg msg = asl_new(ASL_TYPE_MSG);
+    asl_set(msg, ASL_KEY_FACILITY, "com.apple.console");
+    asl_log(logger->asl_client, msg, level, "%s", rb_str_cstr(text));
+    asl_free(msg);
+  }
+  else {
+    rb_warn("log writing failed. closed stream");
+  }
+}
+
+void
+mr_logger_add(VALUE self, SEL sel, VALUE level, VALUE text)
+{
+  logger_add(self, (level == Qnil ? ASL_LEVEL_ALERT : FIX2INT(level)), text);
+}
+
+void
+mr_logger_debug(VALUE self, SEL sel, VALUE text)
+{
+  logger_add(self, ASL_LEVEL_DEBUG, text);
+}
+
+void
+Init_logger()
+{
+  cLogger = rb_define_class("Logger", rb_cObject);
+  
+  rb_objc_define_method(*(VALUE *)cLogger, "alloc", mr_logger_allocate, 0);
+  
+  rb_objc_define_method(cLogger, "initialize", mr_logger_initialize, -1);
+  rb_objc_define_method(cLogger, "add", mr_logger_add, 2);
+  rb_objc_define_method(cLogger, "debug", mr_logger_debug, 1);
+  rb_objc_define_method(cLogger, "close", mr_logger_close, 0);
+  
+  rb_define_alias(cLogger, "log", "add");
+  
+  rb_define_const(cLogger, "EMERGENCY", INT2FIX(ASL_LEVEL_EMERG));
+  rb_define_const(cLogger, "ALERT", INT2FIX(ASL_LEVEL_ALERT));
+  rb_define_const(cLogger, "CRITICAL", INT2FIX(ASL_LEVEL_CRIT));
+  rb_define_const(cLogger, "ERROR", INT2FIX(ASL_LEVEL_ERR));
+  rb_define_const(cLogger, "WARNING", INT2FIX(ASL_LEVEL_WARNING));
+  rb_define_const(cLogger, "NOTICE", INT2FIX(ASL_LEVEL_NOTICE));
+  rb_define_const(cLogger, "INFO", INT2FIX(ASL_LEVEL_INFO));
+  rb_define_const(cLogger, "DEBUG", INT2FIX(ASL_LEVEL_DEBUG));
+  
+  // Ruby's stdlib Logger constant aliases
+  rb_define_const(cLogger, "UNKNOWN", INT2FIX(ASL_LEVEL_ALERT));
+  rb_define_const(cLogger, "FATAL", INT2FIX(ASL_LEVEL_CRIT));
+  rb_define_const(cLogger, "WARN", INT2FIX(ASL_LEVEL_WARNING));
+}

data/spec/add_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Logger#add" do
+  before do
+    @path = tmp("test_log.log")
+    @log_file = File.open(@path, "w+")
+    # @logger = Logger.new(@path)
+    @logger = Logger.new(@log_file)
+  end
+  
+  after do
+    # @logger.close
+    @log_file.close unless @log_file.closed?
+    File.unlink(@path) if File.exists?(@path)
+  end
+  
+  it "writes a new message to the logger" do
+    @logger.add(Logger::WARN, "Test")
+    @log_file.rewind
+    message = @log_file.readlines.last
+    strip_metadata(message).should == "<Warning>: Test\n"
+  end
+  
+  it "receives a severity" do
+    @logger.log(Logger::INFO,  "Info message")
+    @logger.log(Logger::DEBUG, "Debug message")
+    @logger.log(Logger::WARN,  "Warn message")
+    @logger.log(Logger::ERROR, "Error message")
+    @logger.log(Logger::FATAL, "Fatal message")
+    
+    @log_file.rewind
+    
+    info, debug, warn, error, fatal = @log_file.readlines
+    
+    strip_metadata(info).should == "<Info>: Info message\n"
+    strip_metadata(debug).should == "<Debug>: Debug message\n"
+    strip_metadata(warn).should == "<Warning>: Warn message\n"
+    strip_metadata(error).should == "<Error>: Error message\n"
+    # strip_metadata(fatal).should == "<Fatal>: Fatal message\n"
+    strip_metadata(fatal).should == "<Critical>: Fatal message\n"
+  end
+  
+  it "receives a message" do
+    @logger.log(nil, "test")
+    @log_file.rewind
+    # strip_metadata(@log_file.readline).should == "ANY -- : test\n"
+    strip_metadata(@log_file.readline).should == "<Alert>: test\n"
+  end
+  
+  # it "receives a program name" do
+  #   @logger.log(nil, "test", "TestApp")
+  #   @log_file.rewind
+  #   LoggerSpecs::strip_date(@log_file.readline).should == "ANY -- TestApp: test\n"
+  # end
+  # 
+  # it "receives a block" do
+  #   lambda {
+  #     @logger.log(nil, "test", "TestApp") do
+  #       1+1
+  #     end
+  #   }.should_not raise_error
+  # end
+  # 
+  # it "calls the block if message is nil" do
+  #   temp = 0
+  #   lambda {
+  #     @logger.log(nil, nil, "TestApp") do
+  #       temp = 1+1
+  #     end
+  #   }.should_not raise_error
+  #   temp.should == 2
+  # end
+  # 
+  # it "ignores the block if the message is not nil" do
+  #   temp = 0
+  #   lambda {
+  #     @logger.log(nil, "not nil", "TestApp") do
+  #       temp = 1+1
+  #     end
+  #   }.should_not raise_error
+  #   temp.should == 0
+  # end
+end

data/spec/close_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Logger#close" do
+  before do
+    @path = tmp("test_log.log")
+    @log_file = File.open(@path, "w+")
+    @logger = Logger.new(@path)
+  end
+
+  after do
+    @log_file.close unless @log_file.closed?
+    File.unlink(@path) if File.exists?(@path)
+  end
+
+  it "closes the logging device" do
+    @logger.close
+    lambda { @logger.add(nil, "Foo") }.should complain('log writing failed. closed stream')
+  end
+end

data/spec/debug_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+# describe "Logger#debug?" do
+#   before :each do
+#     @path = tmp("test_log.log")
+#     @log_file = File.open(@path, "w+")
+#     @logger = Logger.new(@path)
+#   end
+# 
+#   after :each do
+#     @logger.close
+#     @log_file.close unless @log_file.closed?
+#     File.unlink(@path) if File.exists?(@path)
+#   end
+# 
+#   it "returns true if severity level allows debug messages" do
+#     @logger.level = Logger::DEBUG
+#     @logger.debug?.should == true
+#   end
+#   
+#   it "returns false if severity level does not allow debug messages" do
+#     @logger.level = Logger::WARN
+#     @logger.debug?.should == false
+#   end
+# end
+
+describe "Logger#debug" do
+  before do
+    @path = tmp("test_log.log")
+    @log_file = File.open(@path, "w+")
+    # @logger = Logger.new(@path)
+    @logger = Logger.new(@log_file)
+  end
+
+  after do
+    @logger.close
+    @log_file.close unless @log_file.closed?
+    File.unlink(@path) if File.exists?(@path)
+  end
+
+  it "logs a DEBUG message" do
+    @logger.debug("test")
+    @log_file.rewind
+    strip_metadata(@log_file.readline).should == "<Debug>: test\n"
+  end
+
+  # it "accepts an application name with a block" do
+  #   @logger.debug("MyApp") { "Test message" }
+  #   @log_file.rewind
+  #   strip_metadata(@log_file.readlines.first).should == "DEBUG -- MyApp: Test message\n"
+  # end
+end

data/spec/new_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Logger.new" do
+  before do
+    @file_path = tmp("test_log.log")
+    @log_file = File.open(@file_path, "w+")
+  end
+  
+  after do
+    @log_file.close unless @log_file.closed?
+    File.unlink(@file_path) if File.exists?(@file_path)
+  end
+  
+  it "raises an ArgumentError when given more or less than 1 argument" do
+    lambda { Logger.new }.should.raise ArgumentError
+    lambda { Logger.new(@log_file, @log_file) }.should.raise ArgumentError
+  end
+  
+  it "accepts a logging device as the first argument" do
+    l = Logger.new(@log_file)
+    l.add(Logger::WARN, "Test message")
+    
+    @log_file.rewind
+    strip_metadata(@log_file.readline).should == "<Warning>: Test message\n"
+    l.close
+  end
+  
+  it "accepts a path to a log file as the first argument" do
+    l = Logger.new(@file_path)
+    l.add(Logger::WARN, "Test message")
+    
+    @log_file.rewind
+    strip_metadata(@log_file.readline).should == "<Warning>: Test message\n"
+    l.close
+  end
+end

data/spec/severity_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Logger::Severity" do
+  it "defines Logger severity constants" do
+    Logger::EMERGENCY.should == 0
+    Logger::ALERT.should == 1
+    Logger::CRITICAL.should == 2
+    Logger::ERROR.should == 3
+    Logger::WARNING.should == 4
+    Logger::NOTICE.should == 5
+    Logger::INFO.should == 6
+    Logger::DEBUG.should == 7
+  end
+  
+  it "aliases Ruby’s Logger constants to the compatible ones defined by ASL" do
+    Logger::DEBUG.should == Logger::DEBUG
+    Logger::INFO.should == Logger::INFO
+    Logger::WARN.should == Logger::WARNING
+    Logger::ERROR.should == Logger::ERROR
+    Logger::FATAL.should == Logger::CRITICAL
+    Logger::UNKNOWN.should == Logger::ALERT
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bacon'
+
+Bacon.summary_on_exit
+
+require File.expand_path('../../ext/logger', __FILE__)
+
+require 'tempfile'
+
+class Bacon::Context
+  def tmp(name)
+    File.join(Dir.tmpdir, name)
+  end
+  
+  def strip_metadata(log_line)
+    log_line.sub(/^.+macruby\[\d+\]\s/, '')
+  end
+  
+  def complain(str)
+    lambda do |proc|
+      begin
+        stderr, $stderr = $stderr, IOStub.new
+        verbose, $VERBOSE = $VERBOSE, false
+        
+        proc.call
+        $stderr.include?(str)
+      ensure
+        $stderr = stderr
+        $VERBOSE = verbose
+      end
+    end
+  end
+end
+
+class IOStub < String
+  def write(*str)
+    self << str.join
+  end
+
+  def print(*str)
+    write(str.join + $\.to_s)
+  end
+
+  def puts(*str)
+    write(str.collect { |s| s.to_s.chomp }.concat([nil]).join("\n"))
+  end
+
+  def printf(format, *args)
+    self << sprintf(format, *args)
+  end
+
+  def flush
+    self
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: macruby-asl-logger
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-21 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: A MacRuby wrapper of the Apple System Log facility
+email: eloy.de.enige@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- README
+- Rakefile
+- ext/extconf.rb
+- ext/logger.c
+- spec/add_spec.rb
+- spec/close_spec.rb
+- spec/debug_spec.rb
+- spec/new_spec.rb
+- spec/severity_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/alloy/macruby-asl-logger
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      version: "1.9"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A MacRuby wrapper of the Apple System Log facility
+test_files: 
+- spec/add_spec.rb
+- spec/close_spec.rb
+- spec/debug_spec.rb
+- spec/new_spec.rb
+- spec/severity_spec.rb
+- spec/spec_helper.rb