rcommons 0.8.0

data/lib/commons/lang/time/stop_watch.rb

@@ -0,0 +1,207 @@
+# = Stop Watch
+# 
+#--
+# Ruby version 1.8
+#
+# == Authors
+# * Yomei Komiya
+# 
+# == Copyright
+# 2008 the original author or authors.
+#
+# == License
+# Apache License 2.0
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#  http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+# == Version
+# SVN: $Id: stop_watch.rb 76 2008-10-12 11:45:33Z whitestar $
+#
+# == Since
+# File available since Release 0.8.0
+
+require 'commons/lang/state_error'
+require 'commons/lang/time/duration_format_utils'
+
+module Commons
+  module Lang
+    module Time
+
+      # StopWatch
+      #
+      # Example:
+      #   require 'commons/lang/time/stop_watch'
+      #   # ...
+      #   stop_watch = Commons::Lang::Time::StopWatch.new
+      #   stop_watch.reset
+      #   stop_watch.start
+      #   # ...
+      #   stop_watch.stop
+      #   elapsed_time = stop_watch.get_time    # 7 (milliseconds)
+      #   elapsed_time_str = stop_watch.to_s    # 0:00:00.007      
+      class StopWatch
+        # running states
+        STATE_UNSTARTED = 0
+        STATE_RUNNING = 1
+        STATE_STOPPED = 2
+        STATE_SUSPENDED = 3
+        
+        # split states
+        STATE_UNSPLIT = 10
+        STATE_SPLIT = 11
+        
+                
+        def initialize
+          super()
+          
+          # The current running state of the StopWatch.
+          @running_state = STATE_UNSTARTED
+          
+          # Whether the stopwatch has a split time recorded.
+          @split_state = STATE_UNSPLIT
+          
+          # The start time.
+          @start_time = nil
+          
+          # The stop time.
+          @stop_time = nil
+        end
+        
+        
+        def start
+          if @running_state == STATE_STOPPED
+            raise StateError, 'Stopwatch must be reset before being restarted.'
+          end
+          if @running_state != STATE_UNSTARTED
+            raise StateError, 'Stopwatch already started.'
+          end
+          
+          @stop_time = nil
+          @start_time = ::Time.now
+          @running_state = STATE_RUNNING
+        end
+        
+        
+        def stop
+          if @running_state != STATE_RUNNING && @running_state != STATE_SUSPENDED
+            raise StateError, 'Stopwatch is not running.'
+          end
+          if @running_state == STATE_RUNNING
+            @stop_time = ::Time.now
+          end
+          
+          @running_state = STATE_STOPPED
+        end
+        
+        
+        def reset
+          @running_state = STATE_UNSTARTED
+          @split_state = STATE_UNSPLIT
+          @start_time = nil
+          @stop_time = nil
+        end
+        
+        
+        def split
+          if @running_state != STATE_RUNNING
+            raise StateError, 'Stopwatch is not running.'
+          end
+          
+          @stop_time = ::Time.now
+          @split_state = STATE_SPLIT
+        end
+        
+        
+        def unsplit
+          if @split_state != STATE_SPLIT
+            raise StateError, 'Stopwatch has not been split.'
+          end
+          
+          @stop_time = nil
+          @split_state = STATE_UNSPLIT
+        end
+        
+        
+        def suspend
+          if @running_state != STATE_RUNNING
+            raise StateError, 'Stopwatch must be running to suspend.'
+          end
+          
+          @stop_time = ::Time.now
+          @running_state = STATE_SUSPENDED
+        end
+        
+        
+        def resume
+          if @running_state != STATE_SUSPENDED
+            raise StateError, 'Stopwatch must be suspended to resume.'
+          end
+          
+          @start_time = ::Time.at(@start_time.to_f + (::Time.now - @stop_time))
+          @stop_time = nil
+          @running_state = STATE_RUNNING
+        end
+        
+        
+        # Gets the time in milliseconds
+        def get_time
+          if @running_state == STATE_STOPPED || @running_state == STATE_SUSPENDED
+            return sec_to_millis(@stop_time - @start_time)
+          elsif @running_state == STATE_UNSTARTED
+            return 0
+          elsif @running_state == STATE_RUNNING
+            return sec_to_millis(::Time.now - @start_time)
+          end
+          
+          raise RuntimeError, 'Illegal running state has occured.'
+        end
+        
+        
+        # Gets the split time in milliseconds
+        def get_split_time
+          if @split_state != STATE_SPLIT
+            raise StateError, 'Stopwatch must be split to get the split time.'
+          end
+          
+          return sec_to_millis(@stop_time - @start_time)
+        end
+        
+        
+        def sec_to_millis(sec)
+          return (sec * 1000).to_i
+        end
+        
+        
+        # Gets the start time (Time object).
+        def get_start_time
+          if @running_state == STATE_UNSTARTED
+            raise StateError, 'Stopwatch has not been started'
+          end
+        
+          return @start_time
+        end
+        
+        
+        def to_s
+          return DurationFormatUtils.format_duration_hms(get_time)
+        end
+        
+        
+        def to_split_s
+          return DurationFormatUtils.format_duration_hms(get_split_time)
+        end
+      end
+
+    end
+  end
+end

data/lib/commons/logging/impl/log4r_logger.rb

@@ -0,0 +1,159 @@
+# = Log4r Logger
+# 
+#--
+# Ruby version 1.8
+#
+# == Authors
+# * Yomei Komiya
+# 
+# == Copyright
+# 2008 the original author or authors.
+#
+# == License
+# Apache License 2.0
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#  http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+# == Version
+# SVN: $Id: log4r_logger.rb 77 2008-10-12 12:07:49Z whitestar $
+#
+# == Since
+# File available since Release 0.8.0
+
+require 'log4r/logevent'
+
+require 'commons/ruby/exception'
+require 'commons/ruby/log4r'
+require 'commons/logging/log'
+
+module Commons
+  module Logging
+    module Impl
+
+      class Log4rLogger
+        include Commons::Logging::Log
+        
+        FQCN = self.name
+        
+        # The level of the caller that raises a log event.
+        # ... (2)target_log_event -> (1)Log#log_method -> (0)Logger#log
+        CALLER_LEVEL = 2
+        
+        LOG_PROPAGATED = true
+        
+        
+        def initialize(param)
+          super()
+          
+          case param
+            when String  # logger name
+              @name = param
+              @logger = get_logger()
+            when Log4r::Logger  # logger object, this case for use with a log4r factory.
+              if param == nil
+                raise ArgumentError,
+                  'Warning - nil logger in constructor; possible log4r misconfiguration.'
+              end
+              @name = param.name
+              @logger = param
+            else
+              raise ArgumentError,
+                'Warning - invalid parameter; logger name or logger object is expected.'
+          end
+        end
+        
+        
+        def get_logger
+          if @logger == nil
+            @logger = Log4r::Logger.get_logger(@name)
+          end
+          
+          return @logger
+        end
+        
+        
+        def create_log_event(level, tracer, message)
+          logger = get_logger
+          tracercall = (logger.trace ? tracer : nil)
+          return Log4r::LogEvent.new(level, logger, tracercall, message)
+        end
+        protected :create_log_event
+        
+        
+        def log(level, message, exception = nil)
+          message = build_message(message, exception)
+          
+          case level
+            when TRACE, DEBUG
+              get_logger.debug(
+                create_log_event(Log4r::DEBUG, caller(CALLER_LEVEL), message),
+                LOG_PROPAGATED)
+            when INFO 
+              get_logger.info(
+                create_log_event(Log4r::INFO, caller(CALLER_LEVEL), message),
+                LOG_PROPAGATED)
+            when WARN
+              get_logger.warn(
+                create_log_event(Log4r::WARN, caller(CALLER_LEVEL), message),
+                LOG_PROPAGATED)
+            when ERROR
+              get_logger.error(
+                create_log_event(Log4r::ERROR, caller(CALLER_LEVEL), message),
+                LOG_PROPAGATED)
+            when FATAL
+              get_logger.fatal(
+                create_log_event(Log4r::FATAL, caller(CALLER_LEVEL), message),
+                LOG_PROPAGATED)
+            else
+              # do nothing.
+          end
+        end
+        
+        
+        def build_message(message, exception)
+          if message == nil
+            message = '<nil>'
+          end
+          
+          if exception != nil
+            return message.to_s \
+            + ' <' + exception.class.name + ': ' + exception.message.to_s + '; ' \
+            + exception.stack_trace_string + '>';
+          else
+            return message.to_s
+          end
+        end
+        protected :build_message
+        
+        
+        def enabled_for?(level)
+          case level
+            when TRACE, DEBUG
+              return get_logger.debug?
+            when INFO
+              return get_logger.info?
+            when WARN
+              return get_logger.warn?
+            when ERROR
+              return get_logger.error?
+            when FATAL
+              return get_logger.fatal?
+            else
+              return false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/commons/logging/impl/log_factory_impl.rb

@@ -0,0 +1,253 @@
+# = Log Factory Default Implementation
+# 
+#--
+# Ruby version 1.8
+#
+# == Authors
+# * Yomei Komiya
+# 
+# == Copyright
+# 2008 the original author or authors.
+#
+# == License
+# Apache License 2.0
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#  http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+# == Version
+# SVN: $Id: log_factory_impl.rb 77 2008-10-12 12:07:49Z whitestar $
+#
+# == Since
+# File available since Release 0.8.0
+
+require 'commons'
+require 'commons/io/filename_utils'
+require 'commons/lang/class_loader'
+require 'commons/logging/log'
+require 'commons/logging/log_configuration_error'
+require 'commons/logging/log_factory'
+
+module Commons
+  module Logging
+    module Impl
+
+      class LogFactoryImpl < Commons::Logging::LogFactory
+        # The property name used to identify the LOG_MODULE inclusion class name.
+        LOG_PROPERTY = 'commons.logging.Log'
+        
+        # The fully qualified class name of the log module.
+        LOG_MODULE = 'Commons::Logging::Log'
+        
+        # The log factory setter name.
+        LOG_METHOD_NAME = 'set_log_factory'
+        
+        LOG4R_LOGGER_CLASS = 'Commons::Logging::Impl::Log4rLogger'
+        
+        SIMPLELOG_LOGGER_CLASS = 'Commons::Logging::Impl::SimpleLog'
+        
+        
+        attr_accessor :attributes, :instances, :log_class, :log_method
+        
+        protected :attributes, :instances, :log_class, :log_method
+        
+        
+        def initialize
+          super()
+          
+          @attributes = Hash.new
+          
+          # Already instantiated logger objects. keyed by name.
+          @instances = Hash.new
+          
+          # The fully qualified class name of LOG_MODULE inclusion.
+          @log_class_name = nil
+          
+          # The inclusion class object of the LOG_MODULE
+          @log_class = nil
+          
+          # The one-argument LOG_METHOD_NAME method of the selected
+          # LOG_MODULE inclusion class, if it exists.
+          @log_method = nil          
+        end
+        
+        
+        def get_attribute(name)
+          if @attributes.has_key?(name)
+            return @attributes[name]
+          else
+            return nil
+          end
+        end
+        
+        
+        def get_attribute_names
+          return @attributes.keys
+        end
+        
+        
+        def get_instance(name)
+          unless @instances.has_key?(name)
+            @instances[name] = new_instance(name)
+          end
+          
+          return @instances[name]
+        end
+        
+        
+        def release
+          @instances.clear
+        end
+        
+        
+        def remove_attribute(name)
+          @attributes.delete(name)
+        end
+        
+        
+        def set_attribute(name, value)
+          if value == nil
+            @attributes.delete(name)
+          else
+            @attributes[name] = value
+          end
+        end
+        
+        
+        # Gets Log module inclusion class name.
+        # throws Commons::Logging::LogConfigurationError
+        def get_log_class_name
+          unless @log_class_name == nil
+            return @log_class_name
+          end
+          
+          # 1. Explicitly defined
+          @log_class_name = get_attribute(LOG_PROPERTY)
+          
+          # 2. Environmental variable
+          if @log_class_name == nil
+            env = ENV[LOG_PROPERTY]
+            unless env == nil
+              @log_class_name = env
+            end
+          end
+          # 3. Log4r
+          if @log_class_name == nil && log4r_available?
+            @log_class_name = LOG4R_LOGGER_CLASS
+          end
+          # 4. SimpleLog 
+          if @log_class_name == nil
+            @log_class_name = SIMPLELOG_LOGGER_CLASS
+          end
+          
+          init_log_configuration(@log_class_name)
+          
+          return @log_class_name
+        end
+        protected :get_log_class_name
+        
+        
+        # Initializes logging framework configuration.
+        def init_log_configuration(log_class_name)
+          if log_class_name == LOG4R_LOGGER_CLASS
+            log4r_conf = get_attribute(Commons::LOG4R_CONF_PROPERTY)
+            unless log4r_conf == nil
+              unless Commons::IO::FilenameUtils.absolute?(log4r_conf)
+                log4r_conf = Commons::Lang::ClassLoader.get_resource(log4r_conf)
+              end
+              unless log4r_conf == nil
+                Commons::ENV[Commons::LOG4R_CONF_PROPERTY] = log4r_conf
+              else
+                raise Commons::Logging::LogConfigurationError, 
+                  'Log4r configuration file not found, property key: ' \
+                  + Commons::LOG4R_CONF_PROPERTY
+              end
+            end
+          end
+        end
+        protected :init_log_configuration
+        
+        
+        # Obtains LOG_MODULE inclusion's class.
+        # throws Commons::Logging::LogConfigurationError
+        def get_log_class
+          unless @log_class == nil
+            return @log_class
+          end
+          
+          begin
+            log_class_name = get_log_class_name
+            
+            Commons::Lang::ClassLoader.load(log_class_name)
+            @log_class = eval(log_class_name)
+            if @log_class == nil
+              raise Commons::Logging::LogConfigurationError, 
+                'No suitable Log implementation for ' + log_class_name
+            end
+            unless @log_class.include?(eval(LOG_MODULE))
+              raise Commons::Logging::LogConfigurationError(
+                'Class ' . log_class_name + ' does not include \'' \
+                + LOG_MODULE + '\'.')
+            end
+          rescue Commons::Logging::LogConfigurationError
+            raise
+          rescue Exception => e
+            raise Commons::Logging::LogConfigurationError, e.message
+          end
+          
+          begin
+            @log_method = @log_class.instance_method(LOG_METHOD_NAME)
+          rescue Exception => e
+            @log_method = nil
+          end
+      
+          return @log_class;
+        end
+        protected :get_log_class
+        
+        
+        # Tests whether Log4R is available or not.
+        def log4r_available?
+          # check the resource existence.
+          begin
+            require 'log4r'
+            return true
+          rescue LoadError
+            return false
+          end
+        end
+        protected :log4r_available?
+        
+        
+        # Creates and returns LOG_MODULE instance
+        # throws Commons::Logging::LogConfigurationError
+        def new_instance(name)
+          instance = nil
+          begin
+            # Commons::Logging::Log implementation must have one-argument constructor.
+            instance = get_log_class.new(name)
+            unless @log_method == nil
+              @log_method.bind(instance).call(self)
+            end
+            return instance
+          rescue Commons::Logging::LogConfigurationError
+            raise
+          rescue Exception => e
+            raise Commons::Logging::LogConfigurationError, e.message
+          end
+        end
+        protected :new_instance
+      end
+
+    end
+  end
+end