kazus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12fcb9c3694e8635ad45b26bafd7faac57ec8d3a
+  data.tar.gz: a1cc670ce8c4228839773e9a7ab558e0134eb349
+SHA512:
+  metadata.gz: 0822f449140aa93522664c37ba76f9c85872b5c944a432ce758decfd67bda44b33f3eaf6801391bcb6f46c619e740d07090449bb23a437d078b8b04e39beb570
+  data.tar.gz: b244668c9b2dae2c5e400e71104d6e05b0df9b5c2e8593ca2b69857a558a301aa6f6b2c7d6dd24fa4b59ac18e64777dbc754558b8d0cb43bbfde163e8c779446

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at sebastianbitzer@posteo.de. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kazus.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 esBeee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,174 @@
+# Kazus gem
+
+Kazus provides a simple logging helper. It accepts any amount or type of arguments and logs everything well readable, while including eventually given information like backtraces, validation errors of ActiveModel instances (the gem doesn't depend on rails, though) or the object's length (of an array or a hash). It is designed to not throw errors whatever the arguments are.
+
+For example, lines like
+
+```ruby
+Rails.logger.error "@statement has unexpected validation errors: #{@statement.errors.full_messages.inspect}"
+```
+
+can be replaced by
+
+```ruby
+Kazus.log :error, "Unexpected validation errors", "@statement" => @statement
+```
+
+which logs
+
+```
+[KAZUS|error] Unexpected validation errors -- RELATED OBJECTS:       0.0| TITLE: @statement | CLASS: Statement | ERRORS: User must exist, body can't be blank | INSPECT: #<Statement id: nil, user_id: nil, body: nil, created_at: nil, updated_at: nil> | TO_S: #<Statement:0x007f9a971683c8> |0.0
+```
+
+or simply
+
+```ruby
+Kazus.log @statement
+```
+
+to log
+
+```
+[KAZUS|debug] RELATED OBJECTS:       0| CLASS: Statement | ERRORS: User must exist, body can't be blank | INSPECT: #<Statement id: nil, user_id: nil, body: nil, created_at: nil, updated_at: nil> | TO_S: #<Statement:0x007faffcd962d8> |0
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kazus', git: 'git://github.com/esBeee/kazus.git'
+```
+
+And then execute:
+
+    $ bundle
+
+## Configuration
+
+### In general
+
+You can configure kazus to use another logger than the default [Logger](http://ruby-doc.org/stdlib-2.1.0/libdoc/logger/rdoc/Logger.html). To do so, make sure to call `Kazus.configure` with a block, like
+
+```ruby
+Kazus.configure do |config|
+  config.logger = Rails.logger
+end
+```
+
+to use [Rails.logger](http://guides.rubyonrails.org/debugging_rails_applications.html#what-is-the-logger-questionmark), for example.
+
+### In rails
+
+If you are using rails, you can simply run
+
+```sh
+$ rails generate kazus:install
+```
+
+to copy an initialzer file into `config/initializers/`.
+
+## Usage
+
+The provisioned methods are:
+
+### #Kazus.log
+
+Can be called with an arbitrary amount of arguments without raising an exception. It doesn't make sense to call it without arguments, though. It'll log a warning in this case.
+
+If there's only one argument given, it will be interpreted as the incident description if it's a string or else as an object to be inspected. The log level will be set to `debug` in this case.
+
+Else, if the first argument is a valid log level, which is one of
+
+  * 0, 1, 2, 3, 4 or 5
+
+or
+
+  * :debug, :info, :warn, :error, :fatal or :unknown
+
+or
+
+  * "debug", "info", "warn", "error", "fatal" or "unknown"
+
+or
+
+  * "DEBUG", "INFO", "WARN", "ERROR", "FATAL" or "UNKNOWN"
+
+it will be interpreted as - surprise - log level. If it's anything else, every argument, including the first, will be interpreted as objects to be inspected. The log level will then default to :debug.
+
+If the second argument is a string (while the first argument is a valid log level), it will be interpreted as the incident description (which only has a meaning for formatting of the log message). If it's anything else, it will be interpreted as an object to be inspected as all following arguments are, too.
+
+The third and any following argument will always be interpreted as objects to be inspected.
+
+#### Pattern
+
+All messages include the sequence of letters ```[KAZUS|```. I use this to parse the logs for important messages. If you want to parse for certain log levels, for example ```fatal```, the pattern is ```[KAZUS|fatal]```. Same goes for any other log level named above.
+
+### #Kazus.s
+
+Does almost the same as ```Kazus.log``` but instead of using the configured logger simply uses ```puts```, to log the inspection to STDOUT. Ideal for quick debugging purposes.
+
+## Examples
+
+You can call ```Kazus.log``` with just an array for quick debugging purposes:
+
+```ruby
+Kazus.log [1, "A"]
+```
+
+will output
+
+```
+[KAZUS|debug] RELATED OBJECTS:       0| CLASS: Array | COUNT: 2 | INSPECT: [1, "A"] |0
+```
+
+
+Or you can log an unexpected exception. Kazus includes the backtrace in such cases:
+
+```ruby
+Kazus.log :fatal, "An exception was thrown unexpectedly", exception
+```
+
+will output
+
+```
+[KAZUS|fatal] An exception was thrown unexpectedly -- RELATED OBJECTS:       0| CLASS: Exception | INSPECT: #<Exception: ThisException> | TO_S: ThisException | BACKTRACE: /A/k/o/llad.rb ### /B/k/o/llad.rb |0
+```
+
+
+If the last given argument is a hash, kazus titles each value with its key:
+
+```ruby
+Kazus.log "Number A" => 54, "Number B" => 32
+```
+
+will output
+
+```
+[KAZUS|debug] RELATED OBJECTS:       0.0| TITLE: Number A | CLASS: Fixnum | INSPECT: 54 |0.0       0.1| TITLE: Number B | CLASS: Fixnum | INSPECT: 32 |0.1
+```
+
+
+If you are using rails and you call ```Kazus.log``` with a model instance, its error messages get included in the logs:
+
+```ruby
+statement = Statement.new
+statement.valid? # Generate error messages
+
+Kazus.log :info, nil, statement
+```
+
+will output
+
+```
+[KAZUS|info] RELATED OBJECTS:       0| CLASS: NilClass | INSPECT: nil |0       1| CLASS: Statement | ERRORS: User must exist, body can't be blank | INSPECT: #<Statement id: nil, user_id: nil, body: nil, created_at: nil, updated_at: nil> | TO_S: #<Statement:0x007fb108353318> |1
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/esBeee/kazus. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kazus"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/kazus.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kazus/constants'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kazus"
+  spec.version       = Kazus::VERSION
+  spec.authors       = ["esBeee"]
+  spec.email         = ["sebastianbitzer@posteo.de"]
+
+  spec.summary       = %q{Provides a method that logs a given message along with detailed inspections of all further given objects in a well readable format.}
+  spec.description   = %q{Kazus provides a method to log a given message along with detailed inspections of all further given objects in a well readable format. Any logger can be configured for that job. The method is designed to not throw exceptions under any circumstances, to prevent the including app from breaking even if the method wasn't used as arranged.}
+  spec.homepage      = "https://github.com/esBeee/kazus"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/generators/kazus/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Copies an initializer file into config/initializers/
+
+Example:
+    rails generate kazus:install
+
+    This will create:
+        config/initializers/kazus.rb

data/lib/generators/kazus/install_generator.rb

@@ -0,0 +1,11 @@
+module Kazus
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_initializer
+        template "kazus.rb", "config/initializers/kazus.rb"
+      end
+    end
+  end
+end

data/lib/generators/kazus/templates/kazus.rb

@@ -0,0 +1,4 @@
+Kazus.configure do |config|
+  # Configure any logger you want
+  config.logger = Rails.logger
+end

data/lib/kazus.rb

@@ -0,0 +1,121 @@
+require "kazus/constants"
+require "kazus/configuration"
+require "kazus/incident"
+
+module Kazus
+  class << self
+    # Logs a nicely formatted message with the configured logger or the default
+    # logger, respectively.
+    def log *args
+      # Make sure a logger is available if gem wasn't configured until now.
+      # The Configuration class defaults to the ruby Logger (STDOUT). Learn more
+      # in kazus/configuration.rb.
+      ensure_presence_of_configuration
+
+      # Check if function was called without arguments and return in that case.
+      if args.length == 0
+        error_message = %q{You are calling #Kazus.log without arguments.}
+        return log(:warn, error_message)
+      end
+
+      # Let #map_args decide what the log level will be, what incident description
+      # will be logged, and what objects will be inspected.
+      log_level, incident_description, objects_to_inspect = map_args(args)
+
+      puts_only = __callee__ == :s
+
+      # Return if the current logger has set a log level and the current
+      # incident's log level is beyond the logger's log level.
+      return if !puts_only && severity_beyond_log_level(log_level)
+
+      incident = Incident.new(
+        log_level: log_level,
+        description: incident_description,
+        objects_to_inspect: objects_to_inspect
+      )
+
+      if puts_only
+        puts incident.inspection
+      else
+        incident.log
+      end
+    end
+
+    alias_method :s, :log
+
+
+    private
+
+    # Takes an array and decides based on it, what will be the log level,
+    # the incident description and the objects to be inspected.
+    # Returns an array with those 3 parts:
+    # => [log_level, incident_description, objects_to_inspect]
+    def map_args args
+      # Set log level, incident description, and objects to be inspected.
+      #
+      # Note: if standardize_log_level(args[0]) is nil, the first argument isn't a valid log level.
+      #
+      # Note also, that within this line the log level gets set (for use in
+      # the else-block).
+      if args.length == 1 || (log_level=standardize_log_level(args[0])).nil?
+        # Log as :debug
+        log_level = :debug
+
+        # If the first argument is a string, use it as description.
+        if args[0].class == String
+          incident_description = args[0]
+
+          # Inspect all further objects.
+          objects_to_inspect = args[1..args.length] || []
+        else
+          # No incident description in this case
+          incident_description = nil
+
+          # Assume all objects are to be inspected.
+          objects_to_inspect = args
+        end
+      else
+        # The first argument is a valid log level. Let's check if the second argument
+        # is a string. It will then be interpreted as the incident description, potentially followed
+        # by objects to be inspected.
+        # If it's something else, interpret this and all following arguments as objects
+        # to be inspected.
+        if args[1].class.to_s == "String"
+          incident_description = args[1]
+          objects_to_inspect = args[2..args.length] || []
+        else
+          incident_description = nil
+          objects_to_inspect = args[1..args.length] || []
+        end
+      end
+
+      [log_level, incident_description, objects_to_inspect]
+    end
+
+    # Takes the log level as integer (0, 1, ... , 5) or as string/symbol
+    # (:debug, :info, :warn, :error, :fatal, :unknown) and returns the log level
+    # as symbol.
+    #
+    # Returns nil if given log_level is not valid.
+    def standardize_log_level log_level
+      if log_level.class == Fixnum
+        return nil if log_level < 0 # Prevent the next line from handing out anything in this case
+        LOG_LEVELS[log_level] # Returns nil if log_level > 5
+      else
+        requested_log_level_symbol = log_level.class == String ? log_level.downcase.to_sym : log_level
+        LOG_LEVELS.include?(requested_log_level_symbol) ? requested_log_level_symbol : nil
+      end
+    end
+
+    # Returns true if the current logger has set a log level and the given
+    # log level is beyond the logger's log level.
+    def severity_beyond_log_level log_level
+      loggers_log_level = standardize_log_level(Kazus.configuration.logger.level)
+      if loggers_log_level && LOG_LEVELS.index(log_level) < LOG_LEVELS.index(loggers_log_level)
+        return true
+      end
+    rescue Exception => e
+      # Just ignore if this logger hasn't defined a log level.
+    end
+  end
+end

data/lib/kazus/configuration.rb

@@ -0,0 +1,32 @@
+# Require the default ruby logger 'Logger' in case the user didn't configure
+# a logger.
+require "logger"
+
+module Kazus
+  # This class holds the configuration for the kazus gem.
+  # At the moment only the logger is configurable.
+  class Configuration
+    attr_accessor :logger
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+
+    # This method can be called by the user with a block
+    # so he can configure the gem.
+    def configure
+      ensure_presence_of_configuration
+      yield(configuration)
+    end
+
+    # If gem wasn't configured yet (i.e. Kazus.configuration is nil),
+    # initialize it with a new Configuration instance.
+    def ensure_presence_of_configuration
+      self.configuration ||= Configuration.new
+    end
+  end
+end

data/lib/kazus/constants.rb

@@ -0,0 +1,4 @@
+module Kazus
+  VERSION = "0.1.0"
+  LOG_LEVELS = [:debug, :info, :warn, :error, :fatal, :unknown] # Note that the order is important! (Ensures e.g. :warn corresponds to 2).
+end

data/lib/kazus/incident.rb

@@ -0,0 +1,60 @@
+require "kazus/inspectable"
+
+module Kazus
+  # Class that represents an incident to be logged. Its attributes are
+  #
+  # @log_level <-> Must be one of :debug, :info, :warn, :error, :fatal, :unknown. (To be exact: it
+  #                has to be included in the list of log levels accesible as Kazus::LOG_LEVELS)
+  # @description <-> A string describing the incident or nil, if no description exists.
+  # @objects_to_inspect <-> Must be an array of any length that holds objects that will be inspected and logged.
+  #
+  # You might call it like this:
+  # Incident.new(log_level: 1, description: "Some error occured", objects_to_inspect: [])
+  class Incident
+    def initialize hsh = {}
+      @log_level = hsh[:log_level]
+      @description = hsh[:description]
+      @objects_to_inspect = hsh[:objects_to_inspect]
+    end
+
+    # Comissions the inspections of all given information and merges them
+    # into one string to be logged.
+    def log
+      # Log the message with the given logger.
+      Kazus.configuration.logger.send(@log_level, inspection)
+    rescue
+      # TODO: Whatever can be done in this case
+    end
+
+    def inspection
+      inspection = "[KAZUS|#{@log_level}]"
+      inspection += " " + @description if @description
+      inspection += objects_to_inspect_inspection # Can be a blank string if no objects are given.
+    end
+
+
+    private
+
+    # Returns the inspection of the various objects to be logged.
+    def objects_to_inspect_inspection
+      return "" if @objects_to_inspect.empty?
+
+      inspection = " "
+      inspection += "-- " if @description
+      inspection += "RELATED OBJECTS:"
+
+      # Create an inspection for each given object and add it to the collective inspection.
+      @objects_to_inspect.each_with_index do |object, index|
+        # If it's the last argument, set detailed true. In case it's a hash,
+        # it'll get a special treatment.
+        detailed = (@objects_to_inspect.length - 1 == index)
+
+        # Add individual inspection to collectice inspection.
+        inspection += Inspectable.new(object, index, detailed: detailed).inspection
+      end
+
+      # Return the collective inspection.
+      inspection
+    end
+  end
+end

data/lib/kazus/inspectable.rb

@@ -0,0 +1,160 @@
+module Kazus
+  # Class that represents a single object that should be inspected. Has two attributes:
+  #
+  # @object <-> The object to be inspected. Mandatory.
+  # @id <-> An ID in the overall collection for this object. Can be anything that implements to_s.
+  # @options <-> The options hash. See below for a list of implemented options.
+  # @data <-> A hash used internal to store all debug information to be logged in the end.
+  #
+  # Available options:
+  # :detailed <-> Boolean. If true, titles every key-value-pair of a hash with the key and adds a
+  #               full inspection of the value.
+  #
+  # An instances #inspection method returns a human readable string that gives details about the object.
+  class Inspectable
+    def initialize object, id, options = {}
+      @object = object
+      @id = id
+      @options = options
+      @data = {}
+    end
+
+    # Returns a formatted string that gives a good insight on the object.
+    # Takes a title as first argument optionally, currently used in case 
+    # this object is a value to a key of a hash (then the key is the title).
+    def inspection title=nil
+      # If this object is a hash and options[:detailed] is true,
+      # treat each value as another Inspectable and name the values
+      # with the respective keys.
+      if @options[:detailed] && @object.class == Hash
+        return detailed_hash_values
+      end
+
+      # The following methods all store potentially given
+      # information in @data.
+      collect_title(title)
+      collect_class
+      collect_count
+      collect_errors # Errors here refers to ActiveModel errors.
+      collect_inspect
+      collect_to_s
+      collect_stack_trace
+
+      # Return the full inspection.
+      "       " + id_string(true) + print_data + id_string(false)
+    end
+
+
+    private
+
+    # A simple helper that stores a key-value-pair in the @data hash.
+    def pick_up_data name, information
+      @data[name] = information
+    end
+
+    # Prints all key-value-pairs contained in @data into a well readable string.
+    def print_data
+      printout = ""
+      @data.each { |name, value| printout += name + ": " + value + " | " }
+
+      # Remove superflous last 3 chars.
+      printout.gsub(/ \| $/, "")
+    end
+
+    # Treats every value as an Inspectable and titles it with its key.
+    # Returns the collective inspection-string of all contained key-value-pairs.
+    def detailed_hash_values
+      inspection = ""
+
+      index = 0
+      @object.each do |key, value|
+        inspection += self.class.new(value, "#{@id}.#{index}").inspection(key)
+        index += 1
+      end
+
+      inspection
+    end
+
+    # Hands out the given @id for the left or the right
+    # end of the inspection string, respectively.
+    def id_string right
+      id = @id.to_s
+      right ? id + "| " : " |" + id
+    end
+
+    # Collect the given title.
+    def collect_title title
+      if title
+        # If this is a symbol turn it into a well readable string
+        # For example ":some_value" should become "Some value".
+        message = title.class == Symbol ? title.to_s.gsub("_", " ").capitalize : title.to_s
+        pick_up_data("TITLE", message)
+      end
+    end
+
+    # Collect the object's class name.
+    def collect_class
+      pick_up_data("CLASS", @object.class.to_s)
+    end
+
+    # Collect the object's response to #count, if given.
+    def collect_count
+      # Rescue in case this object doesn't implement a :count method
+      begin
+        count = @object.count
+        pick_up_data("COUNT", @object.count.to_s)
+      rescue
+        # Don't really care if @object doesn't implement :count
+      end
+    end
+
+    # COLLECT methods - Each tries to get an information from @object
+    # and - if available - stores it in the @data hash.
+    #
+    # If this is an ActiveRecord instance, it might have errors that
+    # should be printed.
+    def collect_errors
+      # Rescue in case this object doesn't implement the required methods.
+      begin
+        error_messages = @object.errors.full_messages
+        message = error_messages.length == 0 ? "[]" : error_messages.join(", ")
+        pick_up_data("ERRORS", message)
+      rescue
+        # Don't really care.
+      end
+    end
+
+    # Collect the object's response to #to_s.
+    def collect_to_s
+      s = @object.to_s
+
+      # Don't collect if string is blank or it's the same as #inspect
+      # delivered.
+      unless s.length == 0 || @data["INSPECT"] == s
+        pick_up_data("TO_S", @object.to_s)
+      end
+    end
+
+    # Collect the object's response to #inspect.
+    def collect_inspect
+      s = @object.inspect
+
+      # Don't collect if string is blank or it's the same as #to_s
+      # delivered.
+      unless s.length == 0 || @data["TO_S"] == s
+        pick_up_data("INSPECT", @object.inspect)
+      end
+    end
+
+    # If this object has a backtrace, collect it.
+    def collect_stack_trace
+      # Rescue in case this object doesn't implement the required methods.
+      begin
+        backtrace = @object.backtrace
+        pick_up_data("BACKTRACE", backtrace.join(" ### "))
+      rescue
+        # Don't really care.
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: kazus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- esBeee
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Kazus provides a method to log a given message along with detailed inspections
+  of all further given objects in a well readable format. Any logger can be configured
+  for that job. The method is designed to not throw exceptions under any circumstances,
+  to prevent the including app from breaking even if the method wasn't used as arranged.
+email:
+- sebastianbitzer@posteo.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- kazus.gemspec
+- lib/generators/kazus/USAGE
+- lib/generators/kazus/install_generator.rb
+- lib/generators/kazus/templates/kazus.rb
+- lib/kazus.rb
+- lib/kazus/configuration.rb
+- lib/kazus/constants.rb
+- lib/kazus/incident.rb
+- lib/kazus/inspectable.rb
+homepage: https://github.com/esBeee/kazus
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.5.2
+signing_key: 
+specification_version: 4
+summary: Provides a method that logs a given message along with detailed inspections
+  of all further given objects in a well readable format.
+test_files: []
+has_rdoc: