output 0.0.1

data/lib/output/build_logger.rb

@@ -0,0 +1,31 @@
+module Output
+  class Writer
+    module BuildLogger
+      extend self
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        extend self
+
+        def build_logger(name, level, device_options)
+          logger = Logging.logger[name]
+          logger.level = level
+          logger.appenders = Output::Devices.build_device(device_options[:device], device_options)
+          logger.extend LevelName
+          logger
+        end
+      end
+
+      module LevelName
+        def level_name
+          level_names = Logging::LNAMES
+          level_name =  Logging::levelify level_names[level]
+          level_name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/output/devices.rb

@@ -0,0 +1,100 @@
+module Output
+  module Devices
+    def self.build_device(type, options = {})
+      builders = { 
+        :stdout => Builder::Stdout,
+        :string_io => Builder::StringIo,
+        :file => Builder::File,
+      }
+
+      default_options = { :name => type, :pattern => DEFAULT_PATTERN }
+      options = default_options.merge(options)
+      name = options[:name]
+
+      builder = builders[type]
+      builder.build(name, options)
+    end
+
+    module Builder
+      def layout(pattern = Output::Devices::DEFAULT_PATTERN)
+        Logging.layouts.pattern(:pattern => pattern)
+      end
+
+
+      def build(name, options)
+        pattern = options[:pattern]
+        layout = self.layout(pattern)
+        options = { :layout => layout }.merge(options)
+
+        Logging.appenders.send self.class.device_id, name, options
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def all_required_options
+          @all_required_options ||= []
+        end
+
+        def required_options=(*options)
+          @all_required_options = options
+        end
+        alias :required_options :required_options=
+
+        def device_id=(device_id)
+          @device_id = device_id
+        end
+        alias :device :device_id=
+
+        def device_id
+          @device_id ||= Output::DEFAULT_DEVICE
+        end
+
+        def build(name, options)
+          options.extend Output::Devices::OptionValidation
+          options.validate!(device_id, all_required_options)
+
+          instance = new 
+          instance.build(name, options)
+        end
+      end
+
+      class StringIo
+        include Builder
+
+        device :string_io
+        required_options :pattern
+      end
+
+      class File
+        include Builder
+
+        device :rolling_file
+        required_options :filename, :pattern
+      end
+
+      class Stdout
+        include Builder
+
+        device :stdout
+        required_options :pattern
+      end
+    end
+
+    module OptionValidation
+      def validate!(device_id, required = [])
+        missing_option = false
+        message = "An #{device_id} device requires :\n"
+        required.each do |key|
+          unless self.has_key?(key)
+            missing_option = true
+            message = "#{message}\t :#{key}\n" 
+          end
+        end
+        raise message if missing_option
+      end
+    end
+  end
+end

data/lib/output/output.rb

@@ -0,0 +1,239 @@
+require 'ostruct'
+
+module Output
+  DEFAULT_LOGGER_LEVEL = :info
+  DEFAULT_PATTERN = '%m\n'
+  DEFAULT_DEVICE = :stdout
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  def disable
+    each_writer { |w| w.disable }
+    if block_given?
+      yield
+      enable
+    end
+  end
+
+  def enable
+    each_writer { |w| w.enable }
+  end
+
+  def write(method, message)
+    send method, message
+  end
+
+  def writer(name)
+    send self.class.writer_attribute(name)
+  end
+
+  def last_method
+    @last_method
+  end
+
+  def last_method=(val)
+    @last_method = val
+  end
+
+  def last_method?(*methods)
+    methods.include? last_method
+  end
+
+  def build_writer(name, level, device_options = nil, message_transformer=nil)
+    device_options ||= {}
+    device_options = self.class.device_options.merge device_options
+    logger_name = Writer::Naming.fully_qualified(self.class, name)
+    writer = Writer.build name, level, message_transformer, self.level, logger_name, device_options
+    writer
+  end
+
+  def each_writer
+    self.class.writer_names.each do |name|
+      writer = send self.class.writer_attribute(name)
+      yield writer
+    end
+  end
+
+  def level
+    @level ||= self.class.logger_level
+  end
+
+  def level=(level)
+    @level = level
+    each_writer { |w| w.logger_level = level }
+    level
+  end
+
+  def initial_level?
+    level == self.class.logger_level
+  end
+
+  def levels
+    @levels ||= []
+  end
+
+  def reset_level
+    @level = self.class.logger_level
+
+    each_writer do |writer|
+      writer.reset_level
+    end
+  end
+
+  def push_level(level)
+    levels.unshift self.level
+    self.level = level
+
+    if block_given?
+      yield
+      self.level = pop_level
+    end
+    
+    level
+  end
+
+  def pop_level
+    level = levels.shift unless levels.empty?
+    self.level = level
+    level
+  end
+
+  def suspend_devices(device, &block)
+    return suspend_devices__obj(device, &block) if device.is_a? Logging::Appender
+    suspend_devices__name device, &block
+  end
+
+  def suspend_devices__obj(device, &block)
+    device_selector = ->(writer) { device }
+    suspend_devices__device_selector device_selector, &block
+  end
+
+
+  def suspend_devices__name(name, &block)
+    device_selector = ->(writer) { writer.device name }
+    suspend_devices__device_selector device_selector, &block
+  end
+
+  def suspend_devices__device_selector(device_selector, &block)
+    suspensions = []
+
+    each_writer do |writer|
+      device = device_selector.call writer
+      suspension = Writer::DeviceSuspension.new writer, device
+      suspensions << suspension
+      suspension.suspend
+    end
+
+    yield
+
+    suspensions.each { |suspension| suspension.restore }
+  end
+
+  def to_s
+    details = "Output : #{self.class.name} - Object Id:#{self.object_id}\n"
+    details << "Level: #{self.level}\n"
+    details << "Writer Details: \n"
+    each_writer do |writer|
+      details << "#{writer.to_s}\n"
+    end
+    details
+  end
+
+  def push_device(device, options = {}, &block)
+    return device if device.nil?
+
+    return push_device__obj(device, &block) if device.is_a? Logging::Appender
+
+    push_device__opts(type = device, options, &block)
+  end
+
+  def push_device__opts(type, options = {}, &block)
+    options = self.class.device_options.merge(options)
+    device = Output::Devices.build_device(type, options)
+    push_device__obj device, &block
+  end
+
+  def push_device__obj(device, &block)
+    each_writer do |writer|
+      writer.push_device device
+    end
+    if block_given?
+      yield
+      pop_device
+    end
+    device
+  end
+
+  def pop_device
+    each_writer do |writer|
+      writer.pop_device
+    end
+    nil
+  end
+
+
+  def add_device(device)
+    each_writer do |writer|
+      writer.add_device device
+    end
+    device
+  end
+
+  module ClassMethods
+    def default_pattern
+      @pattern ||= Output::DEFAULT_PATTERN
+    end
+
+    def pattern(format)
+      @pattern = format
+    end
+
+    def default_device_type
+      @device ||= ::Output::DEFAULT_DEVICE
+    end
+
+    def device(device)
+      @device = device
+    end
+
+    def logger_level
+      @logger_level ||= Output::DEFAULT_LOGGER_LEVEL
+    end
+
+
+    def logger_level=(level=nil)
+      @logger_level = level unless level.nil?
+      @logger_level
+    end
+    alias :level :logger_level=
+
+    def writer_names
+      @writer_names ||= []
+    end
+
+    def device_options
+      device_options = {}
+      device_options[:device] = default_device_type
+      device_options[:pattern] = default_pattern
+      device_options
+    end
+
+
+    def writer_macro(name, options = {}, &message_transformer)
+      level = options[:level] || logger_level
+      options = device_options.merge(options)
+
+      WriterMacro.define_writer self, name, level, options,  message_transformer
+      writer_names << name
+    end
+
+    alias :writer :writer_macro
+
+    def writer_attribute(name)
+      Writer::Attribute.attribute_name(name)
+    end
+
+  end
+end

data/lib/output/writer.rb

@@ -0,0 +1,235 @@
+module Output
+  class Writer
+    include BuildLogger
+    include Initializer
+
+    attr_reader :name
+    attr_accessor :level
+    attr_reader :message_transformer
+    attr_reader :enabled
+    attr_writer :devices
+
+    initializer :name, :level, :message_transformer, :logger, :device_options
+
+    def self.build(writer_name, level=Output::DEFAULT_LOGGER_LEVEL, message_transformer=nil, logger_level=Output::DEFAULT_LOGGER_LEVEL, logger_name=nil, device_options)
+      logger_name ||= writer_name
+      logger = build_logger(logger_name, logger_level, device_options)
+      writer = new(writer_name, level, message_transformer, logger, device_options)
+    end
+
+    def devices
+      @devices ||= []
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def enabled?
+      @enabled = true if @enabled.nil?
+      @enabled
+    end
+
+    def logger_level
+      @logger.level_name
+    end
+
+    def logger_level=(level)
+      @logger.level = level
+    end
+
+    def reset_level
+      self.logger_level = level
+    end
+
+    def initial_logger_level?
+      logger_level == level
+    end
+
+    def logger_name
+      @logger.name
+    end
+
+    def write(message)
+      message = message_transformer.call message if message_transformer
+      @logger.send level, message if self.enabled?
+    end
+
+    def add_device(device)
+      @logger.add_appenders device
+      device
+    end
+
+    def device(name)
+      result = nil
+      logger.appenders.each do|device|
+        result = device if device.name == name.to_s
+      end
+      result
+    end
+
+    def number_of_stack_devices
+      devices.count
+    end
+
+    def logger_device?(device)
+      logger.appenders.include? device
+    end
+
+
+
+    def remove_device(device)
+      @logger.remove_appenders device
+      device
+    end
+
+    def logging_appender?(arg)
+      arg.is_a? Logging::Appender
+    end
+
+    def suspend_device(device, &block)
+      return suspend_device__obj device, &block if logging_appender?(device)
+
+      suspend_device__name device, &block
+    end
+
+    def suspend_device__name(name, &block)
+      dvc = device name
+      suspend_device__obj dvc, &block
+    end
+
+    class DeviceSuspension
+      include Initializer
+
+      attr_accessor :logger_device
+      attr_accessor :writer_device
+
+      initializer :writer, :device
+
+      def restore
+        unless device.nil?
+          writer.push_device device if (writer_device)
+          writer.add_device device if (logger_device)
+        end
+      end
+
+
+      def suspend
+        self.logger_device = writer.logger_device? device
+        self.writer_device = writer.device? device
+
+        writer.remove_device device if logger_device
+        writer.devices.delete device if writer_device
+      end
+    end
+
+    def suspend_device__obj(device, &block)
+      suspension = DeviceSuspension.new self, device
+      suspension.suspend
+
+      if block_given?
+        yield
+        suspension.restore
+      end
+      device
+    end
+
+    def push_device__obj(device, &block)
+      raise "The writer:[#{self.name}] already has a device named #{device.name}:[#{device.class}]" if device?(device)
+
+      devices.push device
+
+      add_device device
+
+      if block_given?
+        yield
+        pop_device
+      end
+      device
+    end
+
+    def push_device(device, options = {},  &block)
+      return device if device.nil?
+      return push_device__obj(device, &block) if device.is_a? Logging::Appender
+
+      push_device__opts(type = device, options, &block)
+    end
+
+    def push_device__opts(type, options = {}, &block)
+      options = self.device_options.merge(options)
+      name = options[:name] || type
+
+      raise "Writer:[#{self.name}] - already has a device named [#{name}]. It cannot be pushed the device again" unless device(name).nil?
+
+      device = Output::Devices.build_device(type, options)
+      push_device__obj device, &block
+    end
+
+    def pop_device
+      return if devices.count == 0
+      device = devices.pop
+      remove_device device
+    end
+
+    def device?(device)
+      return false if device.nil?
+      
+      devices.include?(device) || devices.any? { |dvc| dvc.name == device.name }
+    end
+
+    def to_s
+      details = "Writer : #{self.name}\n"
+      details << "\tLevel : #{self.level}\n"
+      details << "\tDevice Stack : \n"
+      devices.each do |device|
+        details << "\t\tDevice : #{device.name} - #{device.class}\n"
+      end
+      details << "\tLogger Appenders : \n"
+      logger.appenders.each do |appender|
+        details << "\t\t\Appender : #{appender.name} - #{appender.class}\n"
+      end
+      details
+    end
+
+    class Attribute
+      include Initializer
+
+      attr_reader :name
+      attr_reader :variable_name
+
+      initializer :name, :variable_name
+
+      def self.build(name)
+        attribute_name = attribute_name(name)
+        variable_name = variable_name(name)
+        new attribute_name, variable_name
+      end
+
+      def self.attribute_name(name)
+        :"#{name}_writer"
+      end
+
+      def self.variable_name(name)
+        :"@#{name}_writer"
+      end
+    end
+
+    module Naming
+      extend self
+
+      def fully_qualified(mod, writer_name)
+        namespace = mod.name
+        writer_name = camel_case(writer_name)
+        "#{namespace}::#{writer_name}"
+      end
+
+      def camel_case(name)
+        name.to_s.split('_').collect { |s| s.capitalize }.join
+      end
+    end
+  end
+end

data/lib/output/writer_macro.rb

@@ -0,0 +1,62 @@
+module Output
+  class WriterMacro
+    include Initializer
+
+    initializer :output_class, :name, :level, :device_options, :message_transformer
+
+    def self.define_writer(output_class, name, level, device_options, message_transformer)
+      macro = new output_class, name, level, device_options, message_transformer
+      macro.define_writer
+    end
+
+    def define_writer
+      define_getter
+      define_setter
+      define_write_method
+    end
+
+    def define_getter
+      name = self.name
+      level = self.level
+      transformer = self.message_transformer
+      device_options = self.device_options
+
+      writer_attribute = Writer::Attribute.build name
+      attribute_name = writer_attribute.name
+      var_name = writer_attribute.variable_name
+
+      output_class.send :define_method, attribute_name do
+        writer = instance_variable_get var_name
+
+        unless writer
+          writer = build_writer(name, level, device_options, transformer) unless writer
+          instance_variable_set var_name, writer
+        end
+
+        writer
+      end
+    end
+
+    def define_setter
+      writer_attribute = Writer::Attribute.build name
+      attribute_name = writer_attribute.name
+      var_name = writer_attribute.variable_name
+
+      output_class.send :define_method, "#{attribute_name}=" do |writer|
+        writer.logger_level = level
+        instance_variable_set var_name, writer
+        writer
+      end
+    end
+
+    def define_write_method
+      name = self.name
+      output_class.send :define_method, name do |message|
+        writer(name).write message
+        self.last_method = name
+        message
+      end
+    end
+  end
+end
+

data/lib/output.rb

@@ -0,0 +1,11 @@
+require 'logging'
+require 'setter'
+require 'single'
+require 'initializer'
+
+require 'output/devices'
+require 'output/writer_macro'
+require 'output/output'
+require 'output/build_logger'
+require 'output/writer'
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: output
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- The Sans Collective
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/output/build_logger.rb
+- lib/output/devices.rb
+- lib/output/output.rb
+- lib/output/writer.rb
+- lib/output/writer_macro.rb
+- lib/output.rb
+homepage: https://github.com/Sans/output
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Output Library
+test_files: []