color-console 0.2 → 0.3

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NTI4ZDk2ZmRhYzFmZWRmODQ2ZTA2Mzg1Y2JmNTdhNWEzNzQwOTY4MQ==
-  data.tar.gz: !binary |-
-    ZDkzNGM2NWI3NmVmZjU4YTYxZjI4MTA3MGJlOGYxNGFjY2MyNjgwYQ==
+SHA1:
+  metadata.gz: eac6c2a764d6f516366d6f5e8470d2ed3b63170d
+  data.tar.gz: aa2c094cf2ad8961fda8bdc3a74c484e0752bab5
 SHA512:
-  metadata.gz: !binary |-
-    NzBmNWIzNjFkYjA0YzcwZTU0NjFkZWU0MGIyZTY0OGYwMjQxNzMzNWIwOWQy
-    Y2YxODcxYzNhZWZkMDI5NDczOWZlMGZiYmM2ZjFiNWQ0OTZiOTU4ZWUyNTVl
-    YTlkNGQ2YzMzZmZhNTgwODMxN2UxMmM3ZDMxYTQ0YzE1MWJmMDM=
-  data.tar.gz: !binary |-
-    M2IxNTFlZDQ4YjRlNDUzZTA1NDU5NWJhODBjZjU4YTJjOWM3MjdiNWY4YTlh
-    ZmQ3NDQyZTdlZTU5NzVkYzJmMTljODFlYTViY2YyYjQzYjgwZTc1NTVjZDRj
-    Y2ZhODU3MGUwY2JmOGVjMzJkYjY5ZWNmYzA5NjVjMjRiMGNjOTg=
+  metadata.gz: 118c4ed399645b94a34d071314f3c0716048ca7044522421cb79b73c337992eab90f41e1326c4983c54d10f90c844fffef86982aa8508022b6ae77cc06b65b60
+  data.tar.gz: 3d60e42deccc08d8e9a9b318e8832b93413410dd9dc7390992fc92bc6ac9cc45a838d258acef608aed02af18fd37457bd7c8730b64cc0201f5f090de35dc3193

data/README.md

@@ -1,8 +1,8 @@
 # ColorConsole
 
-ColorConsole is a small cross-platform library for outputting text to the console.
+ColorConsole is a small cross-platform library for outputting color text to the console, as well as providing utilities for drawing progress bars and outputting tabular data.
 
-On Windows, FFI is used to dynamically link to the Windows Console API functions, while on other platforms, ANSI escape sequences are used. As such, there are no dependencies and no libraries to install other than this gem.
+On Windows, Fiddler (under MRI) or FFI (other engines) is used to dynamically link to the Windows Console API functions, while on other platforms, ANSI escape sequences are used. As such, there are no dependencies and no libraries to install other than this gem.
 
 
 ## Usage
@@ -75,4 +75,14 @@ In addition to `Console.puts` and `Console.write` for outputting text in color,
     |       24 | Lorem ipsum              | Some more text              | Lorem ipsum dolor sit amet  |
     +----------+--------------------------+-----------------------------+-----------------------------+
     ```
+* __Color Logging__: If you are using java.util.logging under JRuby, or the Ruby logging library Log4r, you can obtain colour log messages by replacing the console handler with one provided by this gem:
+    ```ruby
+    # If using Log4r for logging...
+    require 'color_console/log4r_logger'
+    Console.replace_console_logger(level: :info)
+
+    # Or under JRuby with java.util.logging...
+    require 'color_console/java_util_logger'
+    Console.replace_console_logger(level: :fine, format: '%4$-6s %5$s%n')
+    ```
 

data/lib/color-console.rb

@@ -1,2 +1,2 @@
-require 'console/console'
+require 'color_console/console'
 

data/lib/color_console.rb

@@ -1,2 +1,2 @@
-require 'console/console'
+require 'color_console/console'
 

data/lib/color_console/java_util_logger.rb

@@ -0,0 +1,133 @@
+require 'java'
+require_relative '../color_console'
+
+
+# A module for using our color console for log output with the java.util.logging
+# log framework.
+module Console
+
+    module JavaUtilLogger
+
+        include_package 'java.util.logging'
+
+
+        # Extends the java.util.ConsoleHandler, adding colorised logging output to
+        # the console.
+        class ColorConsoleHandler < ConsoleHandler
+
+            def initialize(format = RubyFormatter::DEFAULT_FORMAT)
+                super()
+                self.formatter = RubyFormatter.new(format)
+            end
+
+
+            # Publishes a log record by outputting it to the console, using an
+            # appropriate color for the severity of the log message.
+            def publish(log_record)
+                msg = formatter.format(log_record)
+                case log_record.level
+                when JavaUtilLogger::Level::INFO
+                    Console.write msg, :white
+                when JavaUtilLogger::Level::CONFIG
+                    Console.write msg, :cyan
+                when JavaUtilLogger::Level::FINE
+                    Console.write msg, :light_gray
+                when JavaUtilLogger::Level::SEVERE
+                    Console.write msg, :red
+                when JavaUtilLogger::Level::WARNING
+                    Console.write msg, :yellow
+                else
+                    Console.write msg, :dark_gray
+                end
+            end
+
+        end
+
+
+        # Extends java.util.logging.Formatter, adding the ability to customise the
+        # log format at runtime, and defaulting to a simpler single-line format more
+        # suitable for output to the console.
+        class RubyFormatter < Formatter
+
+            DEFAULT_FORMAT  = '%4$-6s %5$s%n'
+
+            # A format string to use when formatting a log record.
+            # @see Java function String.format for the format string syntax. The
+            #   values passed by this formatter to String.format are:
+            #   - millis  The time the log event occurred
+            #   - source  The name of the logger that logged the record
+            #   - logger_name The name of the logger that logged the record
+            #   - level   The level of the message
+            #   - message The log message
+            #   - thrown  Any exception that forms part of the log record.
+            attr_accessor :format_string
+
+
+            # Constructs a new formatter for formatting log records according to
+            # a format string.
+            #
+            # @param format The format string to use when building a String for
+            #   logging.
+            def initialize(format = DEFAULT_FORMAT)
+                super()
+                @format_string = format
+            end
+
+
+            # Format a log record and return a string for publishing by a log handler.
+            def format(log_record)
+                lvl = case log_record.level
+                      when JavaUtilLogger::Level::WARNING then 'WARN'
+                      when JavaUtilLogger::Level::SEVERE then 'ERROR'
+                      when JavaUtilLogger::Level::FINEST then 'DEBUG'
+                      else log_record.level
+                      end
+                java.lang.String.format(@format_string,
+                                        log_record.millis,
+                                        log_record.logger_name,
+                                        log_record.logger_name,
+                                        lvl,
+                                        log_record.message,
+                                        log_record.thrown)
+            end
+
+        end
+
+    end
+
+
+    # Removes any existing console handler, and adds a ColorConsoleHandler.
+    #
+    # @param options [Hash] An options hash.
+    # @option options [String] logger The name of the logger to replace the
+    #   handler on. Defaults to an empty string, which returns the root logger.
+    # @option options [Level, Symbol] level The level to set the logger to.
+    # @option options [String] format A format string for the layout of the log
+    #   record.
+    def replace_console_logger(options = {})
+        logger = options.fetch(:logger, '')
+        level = options[:level]
+        format = options.fetch(:format, JavaUtilLogger::RubyFormatter::DEFAULT_FORMAT)
+
+        # Remove any existing console handler
+        l = Java::JavaUtilLogging::Logger.getLogger(logger)
+        l.getHandlers.each do |h|
+            l.removeHandler(h) if h.is_a?(Java::JavaUtilLogging::ConsoleHandler)
+        end
+
+        # Add a ColorConsoleHandler
+        h = JavaUtilLogger::ColorConsoleHandler.new(format)
+        l.addHandler(h)
+
+        # Set the log level
+        case level
+        when Symbol, String
+            l.level = Java::JavaUtilLogging::Level.const_get(level.upcase.intern)
+        when Java::JavaUtilLogging::Level
+            l.level = level
+        end
+    end
+    module_function :replace_console_logger
+
+end
+

data/lib/color_console/log4r_logger.rb

@@ -0,0 +1,114 @@
+require 'log4r'
+require_relative '../color_console'
+
+
+# A module for using our color console for log output with the java.util.logging
+# log framework.
+module Console
+
+    module Log4rLogger
+
+
+        # Extends the Log4r StdoutOutputter, adding colorised logging output to
+        # the console.
+        class ColorConsoleOutputter < Log4r::StdoutOutputter
+
+            def initialize(name, options = {})
+                super(name, options)
+                @console_width = Console.width || -1
+            end
+
+
+            def format(event)
+                @fg = case event.level
+                when Log4r::INFO then :white
+                when Log4r::WARN then :yellow
+                when Log4r::ERROR then :red
+                when Log4r::DEBUG then :dark_gray
+                else :light_gray
+                end
+
+                if event.data
+                    begin
+                        thread = Log4r::NDC.peek.to_s.upcase[0, 2]
+                        level = Log4r::LNAMES[event.level]
+                        case
+                        when event.data.is_a?(Exception) || event.data.java_kind_of?(java.lang.Throwable)
+                            msg = Exception.format(event.data)
+                        when event.data.is_a?(Array)
+                            msg = event.data
+                            case msg.first
+                            when String then msg[0] = "%-8s %-2s  %s" % [level, thread, msg[0]]
+                            when Array then msg[0][0] = "%-8s %-2s  %s" % [level, thread, msg[0][0]]
+                            end
+                        else
+                            msg = Console.wrap_text(event.data, @console_width - 16)
+                            msg = msg.each_with_index.map do |line, i|
+                              "%-8s %-2s  %s" % [[level][i], [thread][i], line]
+                            end.join("\n")
+                        end
+                        msg
+                    rescue Object => ex
+                        "(Unable to format event.data)" # due to #{ex})\n"
+                    end
+                else
+                    ""
+                end
+            end
+
+
+            def write(data)
+                if data.is_a?(Array)
+                    if data[0].is_a?(String) && (data.length == 0 || data[1].is_a?(Symbol))
+                        Console.puts *data
+                    else
+                        data.each do |chunk|
+                            Console.write *chunk
+                        end
+                        Console.puts
+                    end
+                else
+                    Console.puts(data, @fg)
+                end
+            end
+
+        end
+
+    end
+
+
+    # Removes any existing console handler, and adds a ColorConsoleHandler.
+    #
+    # @param options [Hash] An options hash.
+    # @option options [String] logger The name of the logger to replace the
+    #   handler on. Defaults to nil, which returns the root logger.
+    # @option options [Level, Symbol] level The level to set the logger to.
+    # @option options [String] format A format string for the layout of the log
+    #   record.
+    def replace_console_logger(options = {})
+        logger = options[:logger]
+        name = options.fetch(:outputter, 'color-console')
+        level = case options.delete(:level)
+        when String, Symbol then Log4r::LNAMES.index(options[:level].to_s.upcase)
+        end
+        STDOUT.puts level
+
+        # Remove any existing console handler
+        log = logger ? Log4r::Logger[logger] : Log4r::Logger.root
+        log = Log4r::Logger.new(logger) unless log
+
+        log.outputters.each do |o|
+            log.remove(o.name) if h.is_a?(Log4r::StdoutOutputter)
+        end
+
+        # Add a ColorConsoleHandler
+        out = Log4rLogger::ColorConsoleOutputter.new(name, options)
+        log.add out
+
+        # Set the log level
+        log.level = level if level
+    end
+    module_function :replace_console_logger
+
+end
+

data/lib/{console → color_console}/platform/windows.rb

@@ -1,59 +1,16 @@
-require 'ffi'
+if RUBY_ENGINE == 'ruby'
+    require_relative 'windows_fiddle'
+else
+    require_relative 'windows_ffi'
+end
+
 
 
 module Console
 
-    # Implements Windows-specific platform functionality
+    # Implements functions for interacting with the console under Windows.
     module Windows
 
-        extend FFI::Library
-
-        ffi_lib 'kernel32.dll'
-        ffi_convention :stdcall
-
-
-        # FFI structure used to get/set information about the current console
-        # window buffer
-        class BufferInfo < FFI::Struct
-            layout  :width, :short,
-                    :height, :short,
-                    :cursor_x, :short,
-                    :cursor_y, :short,
-                    :text_attributes, :ushort,
-                    :window_left, :short,
-                    :window_top, :short,
-                    :window_right, :short,
-                    :window_bottom, :short,
-                    :max_width, :short,
-                    :max_height, :short
-        end
-
-
-        # FFI structure used to get/set buffer co-ordinates
-        class Coord < FFI::Struct
-            layout  :x, :short,
-                    :y, :short
-
-            def initialize(x, y)
-                self[:x] = x
-                self[:y] = y
-            end
-        end
-
-        # Define Windows console functions we need
-        attach_function :get_std_handle, :GetStdHandle, [:uint], :pointer
-        attach_function :get_console_screen_buffer_info, :GetConsoleScreenBufferInfo, [:pointer, :pointer], :bool
-        attach_function :set_console_cursor_position, :SetConsoleCursorPosition, [:pointer, Coord.by_value], :bool
-        attach_function :set_console_text_attribute, :SetConsoleTextAttribute, [:pointer, :ushort], :bool
-        attach_function :set_console_title, :SetConsoleTitleA, [:pointer], :bool
-
-
-        # Constants representing STDIN, STDOUT, and STDERR
-        STD_OUTPUT_HANDLE = 0xFFFFFFF5
-        STD_INPUT_HANDLE = 0xFFFFFFF6
-        STD_ERROR_HANDLE = 0xFFFFFFF7
-
-
         # Retrieve a handle to STDOUT
         def stdout
             @stdout ||= self.get_std_handle(STD_OUTPUT_HANDLE)
@@ -62,14 +19,6 @@ module Console
         private :stdout
 
 
-        # Retrieve a BufferInfo object
-        def buffer_info
-            @buffer_info ||= BufferInfo.new
-        end
-        module_function :buffer_info
-        private :buffer_info
-
-
         # Populate a BufferInfo structure with details about the current
         # buffer state.
         #
@@ -93,17 +42,6 @@ module Console
         module_function :set_color
 
 
-        # Sets the cursor position to the specified +x+ and +y+ locations in the
-        # console output buffer. If +y+ is nil, the cursor is positioned at +x+ on
-        # the current line.
-        def set_cursor_position(x, y)
-            if stdout && x && y
-                coord = Coord.new(x, y)
-                self.set_console_cursor_position(stdout, coord)
-            end
-        end
-        module_function :set_cursor_position
-
     end
 
 
@@ -229,7 +167,14 @@ module Console
             _clear_line (@status.length / self.width) + 1
             @status_displayed = false
         end
-        _write("#{text}\r\n", fg, bg)
+        buffer = Windows.get_buffer_info
+        if buffer && text && text.length > 0 &&
+            text.length == (buffer[:window_right] + 1 - buffer[:cursor_x])
+            # Text length is same as width of window
+            _write("#{text}", fg, bg)
+        else
+            _write("#{text}\r\n", fg, bg)
+        end
         if @status
             _write(@status, @status_fg, @status_bg)
             @status_displayed = true

data/lib/color_console/platform/windows_ffi.rb

@@ -0,0 +1,79 @@
+require 'ffi'
+
+
+module Console
+
+    # Implements Windows-specific platform functionality
+    module Windows
+
+        extend FFI::Library
+
+        # Constants representing STDIN, STDOUT, and STDERR
+        STD_OUTPUT_HANDLE = 0xFFFFFFF5
+        STD_INPUT_HANDLE = 0xFFFFFFF6
+        STD_ERROR_HANDLE = 0xFFFFFFF7
+
+
+        ffi_lib 'kernel32.dll'
+        ffi_convention :stdcall
+
+
+        # FFI structure used to get/set information about the current console
+        # window buffer
+        class BufferInfo < FFI::Struct
+            layout  :width, :short,
+                    :height, :short,
+                    :cursor_x, :short,
+                    :cursor_y, :short,
+                    :text_attributes, :ushort,
+                    :window_left, :short,
+                    :window_top, :short,
+                    :window_right, :short,
+                    :window_bottom, :short,
+                    :max_width, :short,
+                    :max_height, :short
+        end
+
+
+        # FFI structure used to get/set buffer co-ordinates
+        class Coord < FFI::Struct
+            layout  :x, :short,
+                    :y, :short
+
+            def initialize(x, y)
+                self[:x] = x
+                self[:y] = y
+            end
+        end
+
+        # Define Windows console functions we need
+        attach_function :get_std_handle, :GetStdHandle, [:uint], :pointer
+        attach_function :get_console_screen_buffer_info, :GetConsoleScreenBufferInfo, [:pointer, :pointer], :bool
+        attach_function :set_console_cursor_position, :SetConsoleCursorPosition, [:pointer, Coord.by_value], :bool
+        attach_function :set_console_text_attribute, :SetConsoleTextAttribute, [:pointer, :ushort], :bool
+        attach_function :set_console_title, :SetConsoleTitleA, [:pointer], :bool
+
+
+        # Retrieve a BufferInfo object
+        def buffer_info
+            @buffer_info ||= BufferInfo.new
+        end
+        module_function :buffer_info
+        private :buffer_info
+
+
+        # Sets the cursor position to the specified +x+ and +y+ locations in the
+        # console output buffer. If +y+ is nil, the cursor is positioned at +x+ on
+        # the current line.
+        def set_cursor_position(x, y)
+            if stdout && x && y
+                coord = Coord.new(x, y)
+                self.set_console_cursor_position(stdout, coord)
+            end
+        end
+        module_function :set_cursor_position
+
+    end
+
+end
+

data/lib/color_console/platform/windows_fiddle.rb

@@ -0,0 +1,82 @@
+require 'fiddle'
+require 'fiddle/import'
+
+
+module Console
+
+    # Implements Windows-specific platform functionality when running
+    # under MRI. Uses Fiddle, since MRI does not provide FFI functionality
+    # as standard, and furthermore requires a Ruby DevKit installation to
+    # install the ffi gem. This is a royal pain, so we instead use Fiddle
+    # to invoke the Windows console API.
+    module Windows
+
+        extend Fiddle::Importer
+
+        dlload 'kernel32.dll'
+
+
+        # Constant representing STDOUT (0xFFFFFFF5)
+        # We can't use this however, as it overflows to a Bignum!
+        STD_OUTPUT_HANDLE = -11
+
+
+        # Wrap the need to call #call on a Fiddle::Function
+        def self.attach_function(name, sig)
+            func = extern(sig, :stdcall)
+            define_singleton_method(name){ |*args| func.call(*args) }
+        end
+
+
+        # FFI structure used to get/set information about the current console
+        # window buffer
+        BufferInfo = struct([
+            'short width',
+            'short height',
+            'short cursor_x',
+            'short cursor_y',
+            'short text_attributes',
+            'short window_left',
+            'short window_top',
+            'short window_right',
+            'short window_bottom',
+            'short max_width',
+            'short max_height'
+        ])
+
+        class BufferInfo
+            def [](name)
+                self.send(name)
+            end
+        end
+
+        attach_function :get_std_handle, 'void* GetStdHandle(int)'
+        attach_function :get_console_screen_buffer_info, 'int GetConsoleScreenBufferInfo(*void, *void)'
+        attach_function :set_console_cursor_position, 'int SetConsoleCursorPosition(*void, int)'
+        attach_function :set_console_text_attribute, 'int SetConsoleTextAttribute(*void, short)'
+        attach_function :set_console_title, 'int SetConsoleTitleA(*void)'
+
+
+        # Retrieve a BufferInfo object
+        def buffer_info
+            @buffer_info ||= BufferInfo.malloc
+        end
+        module_function :buffer_info
+        private :buffer_info
+
+
+        # Sets the cursor position to the specified +x+ and +y+ locations in the
+        # console output buffer. If +y+ is nil, the cursor is positioned at +x+ on
+        # the current line.
+        def set_cursor_position(x, y)
+            if stdout && x && y
+                coord = y << 16 | x
+                self.set_console_cursor_position(stdout, coord) == 0
+            end
+        end
+        module_function :set_cursor_position
+
+    end
+
+end
+

metadata

@@ -1,32 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: color-console
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: ruby
 authors:
 - Adam Gardiner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2014-12-01 00:00:00.000000000 Z
 dependencies: []
-description: ! "        ColorConsole supports cross-platform (ANSI and Windows) colored
-  text output to the console.\n        It also provides useful methods for building
-  command-line interfaces that provide status\n        messages and progress bars.\n"
+description: |2
+          ColorConsole supports cross-platform (ANSI and Windows) colored text output to the console.
+          It also provides useful methods for building command-line interfaces that provide status
+          messages and progress bars.
 email: adam.b.gardiner@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
 - README.md
+- LICENSE
 - lib/color-console.rb
+- lib/color_console/console.rb
+- lib/color_console/java_util_logger.rb
+- lib/color_console/log4r_logger.rb
+- lib/color_console/platform/ansi.rb
+- lib/color_console/platform/windows.rb
+- lib/color_console/platform/windows_ffi.rb
+- lib/color_console/platform/windows_fiddle.rb
+- lib/color_console/progress.rb
+- lib/color_console/table.rb
 - lib/color_console.rb
-- lib/console/console.rb
-- lib/console/platform/ansi.rb
-- lib/console/platform/windows.rb
-- lib/console/progress.rb
-- lib/console/table.rb
 homepage: https://github.com/agardiner/color-console
 licenses: []
 metadata: {}
@@ -36,17 +41,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: ColorConsole is a cross-platform library for outputting colored text to the