vidazing_logger 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9106df6123f10567ee61da20d022d23c5f43b97a05b2fa9a78291424b6c7b4ad
-  data.tar.gz: e7aaa6373349e1b2b1ac628a28daf169c314a8e3e452ae12a7b021f119427d86
+  metadata.gz: 205ded9bdff5c8cf0b5c2c5b0818b31581e6b151b85ffd9315f34bb23d765236
+  data.tar.gz: f5dc4ccfbdd8edd057e08e6c3fad722466c131b2dec341c406e7f74f2292a1d2
 SHA512:
-  metadata.gz: 5c22b59b28fe9258a8453564f8c4db707ae4a3a84c2b120f8d994ecac31285306420365428f647adc478e281ef4c262b3c942182df3b5532ddc5172944e493c3
-  data.tar.gz: 3bfaf20cd8eead8be172c9839b9c202107510e580ab5ff7510485e04bdc38951785240a60a98400ba1590acceb669c8544840d32c6c05935664beef950f4dddd
+  metadata.gz: 1e21a3d6630b82047c0ea877a77d9f34a3b05b4a61fe2458935aec1044359ee3d8850fe6b5b127f943e33501bf1f8875e110564dd028581ed14553f4414c1860
+  data.tar.gz: 6394c6456b3cedf5f9a3ed0021bf810a8298ac24bf236711b18da822c585821c8697094defdb397b9fb1b8645fd2b138aae0b0f786ccfb394ca529ca973c7807

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -1,3 +1,7 @@
+# Application
+logs/
+
+# General
 *.gem
 *.rbc
 /.config
@@ -36,6 +40,7 @@ build-iPhoneSimulator/
 /rdoc/
 
 ## Environment normalization:
+bundle/
 /.bundle/
 /vendor/bundle
 /lib/bundler/man/

data/.rubocop.yml

@@ -0,0 +1,9 @@
+AllCops:
+  TargetRubyVersion: 2.5.1
+  Exclude:
+    - 'bundle/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - '**/*.rake'
+    - 'test/**/*.rb'

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_filter 'bundle/'
+end

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+
+rvm:
+  - 2.5.1
+before_install:
+  - gem install bundler -v 1.16.4
+
+script:
+  - bundle exec rake build
+  - bundle exec rake doc:build
+  - bundle exec rake test
+
+after_script:
+  - bundle exec rake coveralls:push

data/Gemfile

@@ -1,3 +1,5 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -1,10 +1,15 @@
-# logger-gem
+# logger-gem [![Gem Version](https://badge.fury.io/rb/vidazing_logger.svg)](https://badge.fury.io/rb/vidazing_logger)
+
+[![Build Status](https://travis-ci.org/VidaZing/logger_gem.svg?branch=master)](https://travis-ci.org/VidaZing/logger_gem)
+[![Inline docs](http://inch-ci.org/github/VidaZing/logger_gem.svg?branch=master)](http://inch-ci.org/github/VidaZing/logger_gem)
+[![Coverage Status](https://coveralls.io/repos/github/VidaZing/logger_gem/badge.svg?branch=master)](https://coveralls.io/github/VidaZing/logger_gem?branch=master)
+
 VidaZing logging strategy using [TwP/logging](https://github.com/TwP/logging).
 
 Writes to rolling log files and the corresponding IO pipe.
 
-* <span style="color:red">Red</span> timestamps: `logs/error.log` + stderr.
-* <span style="color:blue">Blue</span> timestamps: `logs/build.log` + stdout.
+* <img src="http://medyk.org/colors/ff8787.png" style="border: 1px solid black" width="20" height="20" /> timestamps for: `logs/error.log` + stderr.
+* <img src="http://medyk.org/colors/87d7ff.png" style="border: 1px solid black" width="20" height="20" /> timestamps for: `logs/build.log` + stdout.
 
 1. [**Installation**](#installation)
 2. [**Usage**](#usage)
@@ -14,7 +19,7 @@ Writes to rolling log files and the corresponding IO pipe.
 1. In your `Gemfile`, add the `vidazing_logger` gem:
 
     ```ruby
-    gem 'vidazing_logger', '~> 0.1'
+    gem 'vidazing_logger', '~> 0.2'
     ```
 
 2. In your `shell`, run:
@@ -39,7 +44,20 @@ See `rake -T`
 ```ruby
 require 'vidazing_logger'
 
-logger = VidazingLogger.logger("OPTIONAL_LOGGER_NAME")
+# Easy
+optional_name = "DearDiary"
+optional_log_dir = 'logs'
+logger = VidazingLogger.logger(optional_name, optional_log_dir)
+
+# Customized. See VidazingLogger::Logger#build
+LoggerBuilder.build(name: @name) do |builder|
+  builder
+    .add_stdout
+    .add_build_log(log_dir: @log_dir)
+    .add_stderr
+    .add_error_log(log_dir: @log_dir)
+end
+
 ```
 
 ### Binary

data/Rakefile

@@ -1,63 +1,82 @@
+# frozen_string_literal: true
+
 require 'rainbow/refinement'
 using Rainbow
 require 'rake/testtask'
+require 'coveralls/rake/task'
 
-$LOAD_PATH.push File.expand_path("../lib", __FILE__)
-require "vidazing_logger/version"
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'vidazing_logger/version'
 VERSION = VidazingLogger::VERSION
 
-GEM_NAME = "vidazing_logger"
+GEM_NAME = 'vidazing_logger'
 
 # IMPORTANT: Color can't be used for `system` commands.
 GEM_NAME_VERSION = "#{GEM_NAME}-#{VERSION}"
 GEM_ARTIFACT = "#{GEM_NAME_VERSION}.gem"
 
-desc "Remove #{GEM_ARTIFACT} && Gemfile.lock"
+desc "Remove #{GEM_ARTIFACT} && Gemfile.lock".blue
 task :clean do
   puts "Removing #{GEM_ARTIFACT} && Gemfile.lock".blue
-  system "rm -f *.gem Gemfile.lock"
+  system 'rm -f *.gem Gemfile.lock'
 end
 
-desc "Build #{GEM_NAME_VERSION}"
-task :build => :clean do
+desc "Build #{GEM_NAME_VERSION}".blue
+task build: :clean do
   puts "Building #{GEM_NAME_VERSION}".blue
   system "gem build #{GEM_NAME}.gemspec"
 end
 
-desc "Publish #{GEM_ARTIFACT}"
+task default: ['build']
+
+desc "Publish #{GEM_ARTIFACT}".blue
 task :publish do
   puts "Publishing #{GEM_NAME_VERSION}".blue
   system "gem push #{GEM_NAME_VERSION}.gem"
 end
 
-desc "Installs #{GEM_ARTIFACT}"
-task :install => :build do
+desc "Installs #{GEM_ARTIFACT}".blue
+task install: :build do
   puts "Installing #{GEM_ARTIFACT}".blue
   system "gem install #{GEM_NAME}"
 end
 
-desc "Uninstalls #{GEM_ARTIFACT}"
+desc "Uninstalls #{GEM_ARTIFACT}".blue
 task :uninstall do
   puts "UNINSTALLING #{GEM_ARTIFACT}".inverse.blue
   system "gem uninstall -xq #{GEM_NAME}"
 end
 
+namespace :dev do
+  desc 'Analyze code quality (rubocop, flog, flay)'
+  task :quality do
+    puts 'Analyzing format with rubocop'.blue
+    system 'bundle exec rubocop'
+
+    puts 'Checking code quality. Lower is better'.blue
+    system 'bundle exec flog lib/'
+
+    puts 'Checking code duplication. Prime to refactor'.blue
+    system 'bundle exec flay lib/'
+  end
+end
+
 namespace :doc do
   desc "Build documentation into 'doc/'"
   task :build do
     puts "Building documentation into 'doc/':".blue
-    system "yard"
+    system 'yard'
   end
 
-  desc "Find undocumented code"
+  desc 'Find undocumented code'
   task :coverage do
-    puts "Documentation coverage:".blue
-    system "yard stats --list-undoc"
+    puts 'Documentation coverage:'.blue
+    system 'yard stats --list-undoc'
   end
 
-  desc "See local documentation at http://localhost:8808"
+  desc 'See local documentation at http://localhost:8808'
   task :serve do
-    system "yard server --reload"
+    system 'yard server --reload'
   end
 end
 
@@ -67,44 +86,59 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
-namespace :loop do
+namespace :loop do # rubocop:disable Metrics/BlockLength
   def looper?
     puts "Checking for 'fswatch' to monitor files".blue
 
-    has_fswatch = ! `which fswatch`.empty?
+    has_fswatch = !`which fswatch`.empty?
+
+    unless has_fswatch
+      abort('fswatch is NOT installed. Visit https://github.com/emcrisostomo/fswatch'.bright.red)
+    end
 
-    abort('fswatch is NOT installed. Visit https://github.com/emcrisostomo/fswatch'.bright.red) unless has_fswatch
     puts('fswatch is installed.'.bright.green) if has_fswatch
   end
 
   def looping(cmd)
-    fswatch_cmd = "fswatch -0 -e .git/ -e *.gem -e logs -e .yardoc -l 1 ."
+    exclude = '-e Gemfile.lock -e .git/ -e *.gem -e logs -e .yardoc -e bundle/'
+    fswatch_cmd = "fswatch -0 #{exclude} -l 1 ."
+
     xargs_cmd = "xargs -0 -I {} sh -c \"echo 'File: {}' && %s\""
+
     looping_cmd = "#{fswatch_cmd} |  #{xargs_cmd}"
+    system format(looping_cmd.to_s, cmd)
+  end
+
+  IGNORED_MESSAGE = 'Ignores .git/, Gemfile.lock, logs/, .yardoc/, bundle/, '\
+                    'and gems created. Watches every 1 seconds'
 
-    system "#{looping_cmd}" % cmd
+  desc 'Repeatedly see dev:quality on file changes'
+  task :"dev:quality" do
+    looper?
+    puts "Analyzing dev:quality on file changes. #{IGNORED_MESSAGE}".blue
+    looping('rake dev:quality')
   end
 
-  IGNORED_MESSAGE = "Ignores .git/, logs/, .yardoc/, and gems created. Watches every 1 seconds"
+  desc 'Repeatedly show documentation coverage on file changes'
+  task :"doc:coverage" do
+    looper?
+    puts "Showing undocumented code on file changes. #{IGNORED_MESSAGE}".blue
+    looping('rake doc:coverage')
+  end
 
-  desc "Repeatedly installs the gem on file changes"
+  desc 'Repeatedly installs the gem on file changes'
   task :install do
     looper?
     puts "Rebuilding on file changes. #{IGNORED_MESSAGE}".blue
-    looping("rake uninstall install")
+    looping('rake uninstall install')
   end
 
-  desc "Repeatedly runs tests on file changes"
+  desc 'Repeatedly runs tests on file changes'
   task :test do
     looper?
     puts "Running tests on file changes. #{IGNORED_MESSAGE}".blue
-    looping("rake test")
-  end
-
-  desc "Repeatedly show documentation coverage on file changes"
-  task :"doc:coverage" do
-    looper?
-    puts "Showing undocumented code on file changes. #{IGNORED_MESSAGE}".blue
-    looping("rake doc:coverage")
+    looping('rake test')
   end
 end
+
+Coveralls::RakeTask.new

data/bin/vidazing_logger

@@ -1,44 +1,57 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'vidazing_logger'
 
 require 'optparse'
 require 'ostruct'
 
+# Handles command line options for the vidazing_logger binary.
+# See `vidazing_logger --help`
+#
+# @since 0.1.0
 class VidazingOptions
-  LEVEL_ALIASES = { 'd' => 'debug', 'i' => 'info', 'w' => 'warn', 'e' => 'error', 'f' => 'fatal' }
+  attr_reader :level, :clean
 
-  def self.parse(args)
-    options = OpenStruct.new
-    options.level = 'info'
-    options.clean = false
+  def initialize
+    @level = 'info'
+    @clean = false
+    @options_parser = create_options_parser
+  end
+
+  def create_options_parser # rubocop:disable Metrics/MethodLength
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: vidazing_logger [options] "Message"'
 
-    options_parser = OptionParser.new do |opts|
-      opts.banner = "Usage: vidazing_logger [options] \"Message\""
+      opts.separator ''
+      opts.separator 'Specific options:'
 
-      opts.separator ""
-      opts.separator "Specific options:"
+      level_aliases = { 'd' => 'debug', 'i' => 'info', 'w' => 'warn',
+                        'e' => 'error', 'f' => 'fatal' }.freeze
+      level_list = level_aliases.flatten.join(',')
 
-      level_list = LEVEL_ALIASES.flatten.join(',')
-      opts.on("-l", "--level LEVEL", LEVEL_ALIASES.values, LEVEL_ALIASES, "Select log level",
-              "  (#{level_list})") do |level|
-        options.level = level
+      opts.on('-l', '--level LEVEL', level_aliases.values, level_aliases,
+              'Select log level', "  (#{level_list})") do |level|
+
+        @level = level
       end
 
-      opts.on_tail("-c", "--clean", "Remove the logs/ directory") do
-        options.clean = true
+      opts.on_tail('-c', '--clean', 'Remove the logs/ directory') do
+        @clean = true
       end
     end
+  end
 
-    options_parser.parse!(args)
-    options
+  def parse(args)
+    @options_parser.parse!(args)
   end
 end
 
-options = VidazingOptions.parse(ARGV)
+vidazing_options = VidazingOptions.new
+vidazing_options.parse(ARGV)
 
-if options.clean
-  puts "Cleaning the logs/ directory"
+if vidazing_options.clean
+  puts 'Cleaning the logs/ directory'
   VidazingLogger.clean
 end
 
@@ -46,5 +59,5 @@ unless ARGV.empty?
   message = ARGV.join(' ')
 
   log = VidazingLogger.logger
-  log.public_send(options.level, message)
+  log.public_send(vidazing_options.level, message)
 end

data/lib/vidazing_logger/appender.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'logging'
+
+module VidazingLogger
+  # An +Appender+ appenders log events to a logging destination.
+  # All appenders use the same layout. So we store the +color_scheme+
+  # instead.
+  #
+  # @api private
+  # @since 0.2.0
+  class Appender
+    attr_reader :filter_levels, :name, :color_scheme
+
+    def initialize(name:, filter_levels:, color_scheme:)
+      @filter_levels = filter_levels
+      @color_scheme = color_scheme
+      @name = name
+    end
+  end
+end

data/lib/vidazing_logger/appenders/build_log.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'vidazing_logger/appenders/log'
+require 'vidazing_logger/color_scheme'
+require 'vidazing_logger/filters/levels'
+
+module VidazingLogger
+  module Appenders
+    # Appender writing to 'logs/build.log'
+    #
+    # @api private
+    # @since 0.2.0
+    class BuildLog < Log
+      def initialize(log_dir:)
+        super \
+          name: 'build',
+          log_dir: log_dir,
+          color_scheme: ColorScheme.normal,
+          filter_levels: Filters::Levels.normal
+      end
+    end
+  end
+end

data/lib/vidazing_logger/appenders/error_log.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'vidazing_logger/appenders/log'
+require 'vidazing_logger/color_scheme'
+require 'vidazing_logger/filters/levels'
+
+module VidazingLogger
+  module Appenders
+    # Appender writing to 'logs/error.log'
+    #
+    # @api private
+    # @since 0.2.0
+    class ErrorLog < Log
+      def initialize(log_dir:)
+        super \
+          name: 'error',
+          log_dir: log_dir,
+          color_scheme: ColorScheme.error,
+          filter_levels: Filters::Levels.error
+      end
+    end
+  end
+end

data/lib/vidazing_logger/appenders/log.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'vidazing_logger/appender'
+
+module VidazingLogger
+  module Appenders
+    # Appender writing to log files
+    #
+    # @api private
+    # @since 0.2.0
+    class Log < Appender
+      attr_reader :log_dir, :name
+
+      def log_path
+        "#{@log_dir}/#{@name}"
+      end
+
+      def initialize(log_dir:, name:, color_scheme:, filter_levels:)
+        @log_dir = log_dir
+        @name = "#{name}.log"
+
+        super \
+          name: log_path,
+          color_scheme: color_scheme,
+          filter_levels: filter_levels
+      end
+    end
+  end
+end

data/lib/vidazing_logger/appenders/logging_gem_adapter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'vidazing_logger/layout_pattern'
+
+require 'logging'
+
+module VidazingLogger
+  module Appenders
+    # Uses an +appender+
+    #
+    # @api private
+    # @since 0.2.0
+    class LoggingGemAdapter
+      attr_reader :vidazing_appender, :logging_appender
+
+      def initialize(type:, vidazing_appender:)
+        @vidazing_appender = vidazing_appender
+
+        logging_filter = create_logging_filter
+        logging_layout = create_logging_layout
+
+        logging_appender_options = create_logging_appender_options \
+          filter: logging_filter,
+          layout: logging_layout
+
+        @logging_appender = create_logging_appender \
+          type: type,
+          name: vidazing_appender.name,
+          options: logging_appender_options
+      end
+
+      private
+
+      def create_logging_appender_options(filter:, layout:)
+        [
+          filters: filter,
+          layout: layout,
+          # These are specific to Appenders::Type.rolling_file
+          # But the underlying logging library uses opts.fetch
+          # So these will be ignored for other appenders types
+          age: 'daily',
+          keep: 7
+        ]
+      end
+
+      def create_logging_appender(type:, name:, options:)
+        abort('options are empty!') if options.empty?
+        abort("Invalid Type '#{type}'") unless Type.valid_type?(type: type)
+
+        options.unshift(name)
+
+        Logging.appenders.public_send(type, *options)
+        Logging.appenders[name]
+      end
+
+      def create_logging_filter # rubocop:disable Metrics/MethodLength
+        # Logging::Filters::Level takes *levels as its argument.
+        # This means we can't store the method arguments ahead of time
+        # in an array and directly pass those.
+        #
+        # Instead, to isolate the Logging gem reference, we hack
+        level0, level1, level2, level3, level4 =
+          *@vidazing_appender.filter_levels
+
+        if level1.nil?
+          Logging::Filters::Level.new(level0)
+        elsif level2.nil?
+          Logging::Filters::Level.new(level0, level1)
+        elsif level3.nil?
+          Logging::Filters::Level.new(level0, level1, level2)
+        elsif level4.nil?
+          Logging::Filters::Level.new(level0, level1, level2, level3)
+        else
+          Logging::Filters::Level.new(:all)
+        end
+      end
+
+      def create_logging_color_scheme
+        color_scheme = @vidazing_appender.color_scheme
+        name = color_scheme.name
+
+        # Logging holds the color scheme reference
+        Logging.color_scheme(name, color_scheme.scheme)
+
+        name
+      end
+
+      def create_logging_layout
+        color_scheme_name = create_logging_color_scheme
+        layout = LayoutPattern.colored(color_scheme_name).layout
+
+        Logging.layouts.pattern layout
+      end
+
+      class << self
+        def stdout(vidazing_appender:)
+          LoggingGemAdapter.new(type: Type::ID_STDOUT,
+                                vidazing_appender: vidazing_appender)
+        end
+
+        def stderr(vidazing_appender:)
+          LoggingGemAdapter.new(type: Type::ID_STDERR,
+                                vidazing_appender: vidazing_appender)
+        end
+
+        def rolling_file(vidazing_appender:)
+          LoggingGemAdapter.new(type: Type::ID_ROLLING_FILE,
+                                vidazing_appender: vidazing_appender)
+        end
+      end
+    end
+
+    # Determines what kind of logging will occur
+    #
+    # @see Type::ID_ROLLING_FILE, Type::ID_STDOUT, Type::ID_STDERR
+    # @api private
+    module Type
+      ID_ROLLING_FILE = 'rolling_file'
+      ID_STDOUT = 'stdout'
+      ID_STDERR = 'stderr'
+
+      TYPES = [ID_ROLLING_FILE, ID_STDERR, ID_STDOUT].freeze
+
+      class << self
+        def valid_type?(type:)
+          is_valid = false
+
+          begin
+            is_valid = Logging.appenders.respond_to?(type)
+          rescue StandardError
+            abort("Logging.appenders.#{type} is not a public_method." \
+                  'See https://github.com/TwP/logging/')
+          end
+
+          is_valid && TYPES.include?(type)
+        end
+      end
+    end
+  end
+end