kojak 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1ccedf06853a170a84c39986ea3baad7ea38347
+  data.tar.gz: 7393b032fc39c06f0e4b311aead7b719165ae23c
+SHA512:
+  metadata.gz: 2a4452b4d5f0bcd9e2e7a10fd787383beb3a4bf58cebe5ffa573d8bba70a958e551df4e41e39b807b9283a60706e024a4237268b9538dd7cb3880f6cf6f7b644
+  data.tar.gz: d18cefa933631004fcb2dd5393970655f670016ce388f46d53cb8099d2a46453bb56f298eeddc66b7bba7625a798b79793ebdfe649dd23a1ad2218c821b73741

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+\#*
+.\#*

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Kris Kovalik
+
+MIT License
+
+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,157 @@
+# Kojak
+
+Kojak is a bald and bold inspector and debug logger for Ruby apps. It aims to
+provide debug (a.k.a. verbose) logging without writing actual any single line
+of logging and printing junk. It also aims to add no overhead to the execution
+whatsoever.
+
+## Introduction
+
+Take a look at the following code...
+
+```ruby
+class SomeFancyTransport
+  # *snip *
+
+  def receive
+    begin
+      log "Waiting for messages ..."
+      line = readline
+      log "Message received, decoding ..."
+      payload = JSON.parse(line)
+      log "Decoded: #{payload.inspect}"
+      log "Acknowledging ..."
+      send(:_ack => true, :_id => payload['_id'])
+      return payload
+    rescue Timeout::Error
+      log "Pinging ..."
+      send(:_ping => true)
+    rescue EOFError
+      log "Connection closed!"
+      @eof = true
+    rescue => err
+      log "Receive error: #{err.to_s}"
+      send(:_err => err.to_h) rescue nil
+    end
+
+    nil
+  end
+end
+```
+
+Uhh, let's face it, this sucks... It looks ugly, getting throuhg and figuring
+out what that function does is complicated. It has 2x much code than it should,
+and even though `log` can be only a stub in non-verbose mode, it'll still takes
+execution time and adds overhead. I heard some wisdom from my friend Jens some
+time ago:
+
+*Your goal toward every single line of code in your app is go get rid of her,
+less code == less bugs.*
+
+So let's get rid of junk...
+
+```ruby
+class SomeFancyTransport
+  # *snip *
+
+  def decode(s)
+    JSON.parse(s)
+  end
+
+  def ack(id)
+    send(:_ack => true, :_id => payload['_id'])
+  end
+
+  def ping
+    send(:_ping => true)
+  end
+
+  def receive_err(err)
+    send(:_err => err.to_h)
+  end
+
+  def eof!
+    @eof = true
+  end
+
+  def receive
+    begin
+      payload = decode(readline)
+      ack(payload['_id'])
+      return payload
+    rescue Timeout::Error
+      ping
+    rescue EOFError
+      eof!
+    rescue => err
+      receive_err(err) rescue nil
+    end
+
+    nil
+  end
+end
+```
+
+Um, but that's more code! Well, yes and no... Let's see, actual code to be
+executed stays the same, rest are just method names and definitions. Though,
+now the code is self documented and it's not sliced through and through
+with junk logging lines. Easier to read, easier to test. But hey... where's the
+logging? Well, here it is:
+
+```ruby
+class SomeFancyTransport
+  extend Kojak::Inspector
+  investigate :readline, :decode, :ack, :ping, ...
+end
+
+Kojak.investigate_all!
+```
+
+Hell yeah, magic! But not so much... `investigate` declares all methods that
+should be inspected. Then `investigate_all!` from `Kojak` goes through all
+these methods and redeclares them - it wraps original method with debugging
+stuff. Now when you call that method, our inspector will gather informatin
+about the execution (arguments, returns, thrown errors, execution time, etc.)
+and nicely print it out for you.
+
+Now answer youself to one very important question. When looking at verbose
+log, what's more important for you? This...
+
+```
+Waiting for messages ...
+Message Received! Decoding ...
+Acknowledging ...
+Receive error: couldn't acknowledge
+```
+
+Or maybe this:
+
+```
+SomeFancyTransport#readline (in ./lib/foo/some_fancy_transport.rb:15):
+| realtime = 10.12388s
+| pid      = 38711
+| input    = []
+| output   = "{\"_id\":\"1\"}"
+SomeFancyTransport#decode (in ./lib/foo/some_fancy_transport.rb:20):
+| realtime = 0.01425s
+| pid      = 38711
+| input    = ["{\"_id\":\"1\"}"]
+| output   = {:id => 1}
+SomeFancyTransport#ack (in ./lib/foo/some_fancy_transport.rb:30):
+| realtime = 0.03331s
+| pid      = 38711
+| input    = [1]
+| error    = #<StandardError: couldn't acknowledge>
+SomeFancyTransport#receive_err (in ./lib/foo/some_fancy_transport.rb:40):
+| realtime = 0.00010s
+| pid      = 38711
+| input    = #<StandardError: couldn't acknowledge>
+| output   = [true, {:_err => {:kind => "standard_error", :message => "couldn't acknowledge"}}]
+```
+
+So here we swapped bunch of crappy logging code that produces a bit of useless
+text messages into self-documented code, with no logging that produces this
+full debug info including source location, input arguments, output and even
+real execution time or pid of the process.
+
+TODO: continue ...

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/{,test_*}/test_*.rb"
+end
+
+task :default => :test

data/examples/hello.rb

@@ -0,0 +1,21 @@
+require 'kojak'
+
+class Hello
+  extend Kojak::Inspector
+  investigate :greet, :this_one_does_nothing
+
+  def greet(attrs = {})
+    raise ArgumentError.new("missing name") unless attrs[:name]
+    "Hello #{attrs[:name]}!"
+  end
+
+  def this_one_does_nothing
+  end
+end
+
+Kojak.investigate!
+
+h = Hello.new
+h.greet(:name => "Jon Snow")
+h.greet(:a => 1, :b => 2, :c => 3) rescue nil
+h.this_one_does_nothing

data/examples/more_complex.rb

@@ -0,0 +1,39 @@
+require 'kojak'
+
+class Hello
+  extend Kojak::Inspector
+  investigate :greet, :this_one_does_nothing
+
+  def greet(attrs = {})
+    raise ArgumentError.new("missing name") unless attrs[:name]
+    "Hello #{attrs[:name]}!"
+  end
+
+  def this_one_does_nothing
+  end
+end
+
+class HelloTyrion < Hello
+  extend Kojak::Inspector
+  investigate :greet, :this_one_takes_a_while
+
+  def greet(attrs = {})
+    super(:name => "Tyrion Lannister")
+  end
+
+  def this_one_takes_a_while
+    sleep(1.2)
+  end
+end
+
+Kojak.investigate!
+
+h1 = Hello.new
+h1.greet(:name => "Jon Snow")
+h1.greet(:a => 1, :b => 2, :c => 3) rescue nil
+h1.this_one_does_nothing
+
+h2 = HelloTyrion.new
+h2.greet(:foo => :bar)
+h2.this_one_does_nothing
+h2.this_one_takes_a_while

data/kojak.gemspec

@@ -0,0 +1,27 @@
+# -*- mode: ruby -*-
+# -*- coding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kojak/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kojak"
+  spec.version       = Kojak::VERSION
+  spec.authors       = ["Kris Kovalik", "NIMBOOST Team"]
+  spec.email         = ["dev@nimboost.com"]
+  spec.summary       = %q{Kojak is a neat and bald tracer and debug logger.}
+  spec.description   = %q{Kojak allows you to trace and debug method calls.}
+  spec.homepage      = "http://docs.nimboost.com/lib/ruby/kojak"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json", "~> 1.8"
+  spec.add_dependency "rainbow", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mocha"
+end

data/lib/kojak.rb

@@ -0,0 +1,12 @@
+require "benchmark"
+
+module Kojak
+  require "kojak/version"
+  require "kojak/printer"
+  require "kojak/caller"
+  require "kojak/inspector"
+  require "kojak/output"
+  require "kojak/central"
+
+  extend Central
+end

data/lib/kojak/caller.rb

@@ -0,0 +1,58 @@
+module Kojak
+  # Internal: Caller wraps a method with inspection mechanism.
+  class Caller < Hash
+    # Public: Constructor. Wraps given method with caller. Gathers initial
+    # information about this call.
+    #
+    # method - The Method to be wrapped.
+    #
+    # Returns nothing.
+    def initialize(method)
+      @method = method
+
+      replace({
+        :name      => "#{method.owner.name}##{method.name}",
+        :method    => method,
+        :location  => method.source_location,
+        :pid       => Process.pid,
+        :thread    => Thread.current,
+        :thread_id => Thread.object_id,
+      })
+    end
+
+    # Public: Calls wrapped method with given arguments and block, and
+    # collects all information about this particular call.
+    #
+    # args  - The Array with arguments to pass.
+    # block - The Proc with block to pass.
+    #
+    # Returns stuff returned by called method. Raises exceptions
+    # by called method if any.
+    def call(*args, &block)
+      merge!({
+        :block_given => block_given?,
+        :block       => block,
+        :args        => args
+      })
+
+      res, err = nil, nil
+      rt = Benchmark.realtime do
+        begin
+          res = @method.call(*args, &block)
+        rescue Exception => e
+          err = e
+        end
+      end
+
+      merge!({
+        :receiver => @method.receiver.class.name,
+        :realtime => rt,
+        :result   => res,
+        :err      => err
+      })
+
+      raise err if err
+      res
+    end
+  end
+end

data/lib/kojak/central.rb

@@ -0,0 +1,54 @@
+require "thread"
+
+module Kojak
+  # Internal: An extension with central utilities. This module extends top
+  # level Kojak module, don't use it directly.
+  module Central
+    # Global mutex.
+    @@mtx = Mutex.new
+
+    # Slow log of investigated methods. Contains list of called names in
+    # order of calling.
+    @@log = Array.new
+
+    # Global printer.
+    @@printer = Printer::RandomlyColorized.new($stderr)
+
+    # Investigated classes.
+    @@investigated = {}
+
+    # Internal: Returns slow log array.
+    def slowlog
+      @@mtx.synchronize { @@log }
+    end
+
+    # Internal: List of classes marked for investigation.
+    def investigated
+      @@mtx.synchronize { @@investigated.values }
+    end
+
+    # Internal: Marks given class as investigated.
+    #
+    # cls - The Class to register.
+    #
+    # Returns list of investigated classes.
+    def mark_for_investigation(cls)
+      @@mtx.synchronize { @@investigated[cls.object_id] = cls }
+    end
+
+    # Internal: Prints investigation results and writes to slow log.
+    #
+    # caller - The Caller to print.
+    #
+    # Returns nothing.
+    def print(caller)
+      @@mtx.synchronize { @@log << caller[:name] }
+      @@printer.puts(Output.new(caller))
+    end
+
+    # Internal: Enables investigation of all registered classes.
+    def investigate!
+      @@mtx.synchronize { @@investigated.values.each(&:investigate!) }
+    end
+  end
+end

data/lib/kojak/inspector.rb

@@ -0,0 +1,62 @@
+module Kojak
+  # Internal: Registers investigator within given class for specified method.
+  #
+  # cls - The Class that will be affected.
+  # m   - The Method to override with investigation support.
+  #
+  # Returns nothing.
+  def self.register_investigator_for!(cls, m)
+    cls.send(:define_method, m.name) do |*args,&block|
+      begin
+        caller = Caller.new(m.bind(self))
+        caller.call(*args,&block)
+      ensure
+        Kojak.print(caller) if caller
+      end
+    end
+  end
+
+  # Public: Extend your class with this inspector module to get
+  # investigation functionality.
+  #
+  # Example
+  #
+  #   class Dummy
+  #     investigate :foo, :bar
+  #
+  #     def foo
+  #       *snip*...
+  #     end
+  #
+  #     def bar
+  #       *snip*...
+  #     end
+  #   end
+  #
+  #   Dummy.investigate! # ... or Kojak.investigate_all!
+  #
+  module Inspector
+    def self.extended(cls)
+      Kojak.mark_for_investigation(cls)
+    end
+
+    # Public: Marks given methods for investigation.
+    #
+    # names - The Array of method names to investigate.
+    #
+    # Returns Array with names of all methods being under investigation.
+    def investigate(*names)
+      Kojak.mark_for_investigation(self)
+      @__kojak_investigate ||= []
+      @__kojak_investigate.concat(names).uniq!
+    end
+
+    # Public: Enables investigation of caller class.
+    def investigate!
+      @__kojak_investigate.each do |name|
+        m = instance_method(name)
+        Kojak.register_investigator_for!(self, m)
+      end
+    end
+  end
+end

data/lib/kojak/output.rb

@@ -0,0 +1,66 @@
+module Kojak
+  # Internal: Pretty output string from given caller information.
+  class Output < String
+    # Public: Constructor. Generates output from given caller.
+    def initialize(caller)
+      @c = caller
+      super("\n" + all.flatten.compact.join("\n") + "\n")
+    end
+
+    def all
+      [
+        header, receiver, location, pid, realtime, arguments, 
+        result, err, footer
+      ]
+    end
+
+    def header
+      "=== #{@c[:name]} ".ljust(80, "=")
+    end
+
+    def receiver
+      "receiver_class=#{@c[:receiver]}"
+    end
+
+    def location
+      "source_location=#{@c[:location].join(":")}"
+    end
+
+    def pid
+      "pid=#{@c[:pid]}"
+    end
+
+    def realtime
+      "real_time=%.5f" % @c[:realtime]
+    end
+
+    def arguments
+      args = @c[:args]
+      return if !args || args.empty?
+      ["--- arguments ".ljust(80, '-'), pp(args)]
+    end
+
+    def result
+      res = @c[:result]
+      return if res.nil?
+      ["--- result ".ljust(80, '-'), pp(res)]
+    end
+
+    def err
+      err = @c[:err]
+      return if err.nil?
+      errname = err.class.name + ": " + err.to_s
+      ["--- exception ".ljust(80, '-'), errname]
+    end
+
+    def footer
+      "=" * 80
+    end
+
+    protected
+
+    def pp(x)
+      JSON.pretty_generate(x) rescue x.inspect
+    end
+  end
+end

data/lib/kojak/printer.rb

@@ -0,0 +1,34 @@
+require 'rainbow'
+
+module Kojak
+  # Internal: Abstract design of a printing class.
+  #
+  # This is just a stub with documentation, implement actual printers
+  # in inherited classes.
+  class Printer
+    # Public: Writes given string and a newline.
+    #
+    # s    - The String to print.
+    # args - The Array with interpolation arguments.
+    #
+    # Should return number of writen characters.
+    def puts(s, *args)
+      write("#{s}\n", *args)
+    end
+
+    # Public: Writes given string to the output.
+    #
+    # s    - The String to print.
+    # args - The Array with interpolation arguments.
+    #
+    # Should return number of written characters.
+    def write(s, *args)
+    end
+  end
+
+  require 'kojak/printer/nulled'
+  require 'kojak/printer/basic'
+  require 'kojak/printer/synchronized'
+  require 'kojak/printer/colorized'
+  require 'kojak/printer/randomly_colorized'
+end

data/lib/kojak/printer/basic.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+module Kojak
+  # Internal: Basic printer. It prints stuff to configured output stream.
+  class Printer::Basic < Printer
+    # Public: Constructor. Configures printer to write to given output stream.
+    #
+    # out - The Stream to write data to.
+    #
+    # Returns nothing.
+    def initialize(out)
+      @out = out
+    end
+
+    def write(s, *args)
+      args = args.map { |x| JSON.pretty_generate(x) rescue x.inspect }
+      @out.write(s.to_s % args)
+    end
+  end
+end

data/lib/kojak/printer/colorized.rb

@@ -0,0 +1,28 @@
+require 'rainbow'
+
+module Kojak
+  # Internal: Special version of thread-safe printer that additionally colorizes
+  # the output with one preconfigured color.
+  class Printer::Colorized < Printer::Synchronized
+    # Public: The String or Symbol with name of the assigned color.
+    attr_accessor :color
+
+    # Public: Constructor. Configures printer to write to given output in
+    # specified color.
+    #
+    # out   - The Stream to write data to.
+    # color - The String or Symbol with name of the color to use.
+    #
+    # Returns nothing.
+    def initialize(out, color = :white)
+      super(out)
+
+      @color   = color
+      @rainbow = Rainbow.new
+    end
+
+    def write(s, *args)
+      super(@rainbow.wrap(s.to_s).color(color), *args)
+    end
+  end
+end

data/lib/kojak/printer/nulled.rb

@@ -0,0 +1,7 @@
+module Kojak
+  # Internal: Nulled printer.
+  class Printer::Nulled < Printer
+    def puts(s, *args)
+    end
+  end
+end

data/lib/kojak/printer/randomly_colorized.rb

@@ -0,0 +1,30 @@
+require 'rainbow'
+
+module Kojak
+  # Internal: Colorized logger that uses random color from the palette.
+  class Printer::RandomlyColorized < Printer::Colorized
+    # Internal: List of colors to pick from. This list is always
+    # randomized on start.
+    PALETTE = %w[
+      #af8700 #af875f #af8787 #af87af #af87d7 #af87ff #afaf00 #afaf5f
+      #afafaf #afafd7 #afafff #afd700 #afd75f #afd787 #afd7af #afd7d7
+      #afd7ff #afff00 #afff5f #afff87 #afffaf #afffd7 #afffff #878787
+      #8787af #8787d7 #8787ff #87af00 #87af5f #87af87 #87afaf #87afd7
+      #87afff #87d700 #87d75f #87d787 #87d7af #87d7d7 #87d7ff #87ff00
+      #87ff5f #87ff87 #87ffaf #87ffd7 #87ffff #d78700 #d7875f #d78787
+      #d787af #d787d7 #d787ff #d7af00 #d7af5f #d7af87 #d7afaf #d7afd7
+    ].compact.shuffle
+
+    def initialize(out)
+      super(out, nil)
+      @current = -1
+    end
+
+    def color
+      @@lock.synchronize do
+        @current += 1
+        PALETTE[@current % PALETTE.size]
+      end
+    end
+  end
+end

data/lib/kojak/printer/synchronized.rb

@@ -0,0 +1,10 @@
+module Kojak
+  # Internal: Thread-safe version of Printer::Basic.
+  class Printer::Synchronized < Printer::Basic
+    @@lock = Mutex.new
+
+    def write(s, *args)
+      @@lock.synchronize { super }
+    end
+  end
+end

data/lib/kojak/version.rb

@@ -0,0 +1,3 @@
+module Kojak
+  VERSION = "0.0.1"
+end

data/test/dummies/dummy.rb

@@ -0,0 +1,9 @@
+class Dummy
+  def dummy1(opts = {})
+    1
+  end
+
+  def dummy2(a, b)
+    2
+  end
+end

data/test/minitest_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'kojak'
+require 'minitest/autorun'
+require 'mocha/mini_test'
+
+Dir[File.expand_path("../dummies/*.rb", __FILE__)].each do |f|
+  require f
+end

data/test/test_caller.rb

@@ -0,0 +1,73 @@
+require 'minitest_helper'
+
+describe Kojak::Caller do
+  let(:obj) do
+    Dummy.new
+  end
+
+  let(:method) do
+    :dummy1
+  end
+
+  let(:caller) do
+    Kojak::Caller.new(obj.method(method))
+  end
+
+  describe "initialize" do
+    it "should gather base information about the method" do
+      caller[:name].must_equal "#{obj.class.name}##{method}"
+      caller[:method].must_equal obj.method(method)
+      caller[:location].must_equal obj.method(method).source_location
+      caller[:pid].must_equal Process.pid
+      caller[:thread_id].must_equal Thread.object_id
+      caller[:thread].must_equal Thread.current
+    end
+  end
+
+  describe "call" do
+    describe "when normal call" do
+      it "should store args" do
+        args = {:foo => 1}
+        caller.call(args)
+        caller[:args].must_equal [args]
+        caller[:block].must_be_nil
+        caller[:block_given].must_equal false
+      end
+
+      it "should return same result as method would" do
+        res = caller.call
+        res.must_equal 1
+        caller[:result].must_equal res
+      end
+
+      it "should measure execution time" do
+        res = caller.call
+        caller[:realtime].must_be ">", 0
+      end
+    end
+
+    describe "when block given" do
+      it "should store info about the block" do
+        block = proc {}
+        caller.call(&block)
+        assert_equal caller[:block], block
+        caller[:block_given].must_equal true
+      end
+    end
+
+    describe "when error raised from method" do
+      let(:method) do
+        :dummy2
+      end
+
+      it "should capture it and re raise" do
+        res = nil
+        err = assert_raises ArgumentError do
+          res = caller.call(1,2,3,4)
+        end
+        caller[:err].must_equal err
+        caller[:result].must_be_nil
+      end
+    end
+  end
+end

data/test/test_inspector.rb

@@ -0,0 +1,35 @@
+require 'minitest_helper'
+
+describe Kojak::Inspector do
+  let(:cls) do
+    Class.new(Dummy) do
+      extend Kojak::Inspector
+      investigate :dummy1
+    end
+  end
+
+  let(:obj) do
+    cls.new
+  end
+
+  before do
+    cls.extend(Kojak::Inspector)
+  end
+
+  describe "investigation" do
+    it "should register class in top level" do
+      assert Kojak.investigated.include?(cls)
+    end
+
+    it "should redefine investigated methods" do
+      cls.investigate!
+      res = nil
+      out, err = capture_subprocess_io do
+        res = obj.dummy1(:foo => 1)
+      end
+      res.must_equal(1)
+      err.must_match(/Dummy#dummy1/)
+      Kojak.slowlog.last.must_equal("Dummy#dummy1")
+    end
+  end
+end

data/test/test_printer/test_basic.rb

@@ -0,0 +1,51 @@
+require 'minitest_helper'
+require 'stringio'
+
+describe Kojak::Printer::Basic do
+  let(:out) do
+    StringIO.new
+  end
+
+  let(:printer) do
+    Kojak::Printer::Basic.new(out)
+  end
+
+  let(:text) do
+    "foo"
+  end
+
+  describe "write" do
+    it "should write given string to the output" do
+      printer.write(text)
+      out.seek(0)
+      out.read.must_equal(text)
+    end
+
+    describe "interpolation" do
+      it "should interpolate text" do
+        printer.write("%s", text)
+        out.seek(0)
+        out.read.must_equal(text.inspect)
+      end
+
+      describe "with objects" do
+        let(:obj) do
+          {:foo => 1}
+        end
+
+        it "should pretty print interpolated objects" do
+          printer.write("%s", obj)
+          out.seek(0)
+          out.read.must_equal(JSON.pretty_generate(obj))
+        end
+      end
+    end
+  end
+
+  describe "puts" do
+    it "should write given string and newline to the output" do
+      printer.expects(:write).with(text + "\n")
+      printer.puts(text)
+    end
+  end
+end

data/test/test_printer/test_colorized.rb

@@ -0,0 +1,31 @@
+require 'minitest_helper'
+require 'stringio'
+
+describe Kojak::Printer::Colorized do
+  let(:out) do
+    StringIO.new
+  end
+
+  let(:printer) do
+    Kojak::Printer::Colorized.new(out, :red)
+  end
+
+  let(:text) do
+    "foo"
+  end
+
+  describe "write" do
+    it "should write given string to the output" do
+      printer.write(text)
+      out.seek(0)
+      out.read.must_equal("\e[31m#{text}\e[0m")
+    end
+  end
+
+  describe "puts" do
+    it "should write given string and newline to the output" do
+      printer.expects(:write).with(text + "\n")
+      printer.puts(text)
+    end
+  end
+end

data/test/test_printer/test_nulled.rb

@@ -0,0 +1,24 @@
+require 'minitest_helper'
+require 'stringio'
+
+describe Kojak::Printer::Nulled do
+  let(:printer) do
+    Kojak::Printer::Nulled.new
+  end
+
+  let(:text) do
+    "foo"
+  end
+
+  describe "write" do
+    it "should do nothing" do
+      printer.write(text)
+    end
+  end
+
+  describe "puts" do
+    it "should do nothing" do
+      printer.puts(text)
+    end
+  end
+end

data/test/test_printer/test_randomly_colorized.rb

@@ -0,0 +1,25 @@
+require 'minitest_helper'
+require 'stringio'
+
+describe Kojak::Printer::RandomlyColorized do
+  let(:out) do
+    StringIO.new
+  end
+
+  let(:printer) do
+    Kojak::Printer::RandomlyColorized.new(out)
+  end
+
+  it "should be colorized" do
+    printer.must_be_kind_of Kojak::Printer::Colorized
+  end
+
+  it "should always pick different color" do
+    prev = nil
+    100.times do
+      current = printer.color
+      current.wont_equal prev
+      prev = current
+    end
+  end
+end

data/test/test_printer/test_synchronized.rb

@@ -0,0 +1,31 @@
+require 'minitest_helper'
+require 'stringio'
+
+describe Kojak::Printer::Synchronized do
+  let(:out) do
+    StringIO.new
+  end
+
+  let(:printer) do
+    Kojak::Printer::Synchronized.new(out)
+  end
+
+  let(:text) do
+    "foo"
+  end
+
+  describe "write" do
+    it "should write given string to the output" do
+      printer.write(text)
+      out.seek(0)
+      out.read.must_equal(text)
+    end
+  end
+
+  describe "puts" do
+    it "should write given string and newline to the output" do
+      printer.expects(:write).with(text + "\n")
+      printer.puts(text)
+    end
+  end
+end

data/test/test_top_level.rb

@@ -0,0 +1,17 @@
+require 'minitest_helper'
+
+describe Kojak do
+  it "should have correct version number" do
+    Kojak::VERSION.must_equal "0.0.1"
+  end
+
+  describe "investigate!" do
+    it "should run investigation on all registered classes" do
+      dummy = Class.new { extend Kojak::Inspector }
+      dummy.expects(:investigate!)
+      Kojak.investigated.clear
+      Kojak.mark_for_investigation(dummy)
+      Kojak.investigate!
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: kojak
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kris Kovalik
+- NIMBOOST Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Kojak allows you to trace and debug method calls.
+email:
+- dev@nimboost.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/hello.rb
+- examples/more_complex.rb
+- kojak.gemspec
+- lib/kojak.rb
+- lib/kojak/caller.rb
+- lib/kojak/central.rb
+- lib/kojak/inspector.rb
+- lib/kojak/output.rb
+- lib/kojak/printer.rb
+- lib/kojak/printer/basic.rb
+- lib/kojak/printer/colorized.rb
+- lib/kojak/printer/nulled.rb
+- lib/kojak/printer/randomly_colorized.rb
+- lib/kojak/printer/synchronized.rb
+- lib/kojak/version.rb
+- test/dummies/dummy.rb
+- test/minitest_helper.rb
+- test/test_caller.rb
+- test/test_inspector.rb
+- test/test_printer/test_basic.rb
+- test/test_printer/test_colorized.rb
+- test/test_printer/test_nulled.rb
+- test/test_printer/test_randomly_colorized.rb
+- test/test_printer/test_synchronized.rb
+- test/test_top_level.rb
+homepage: http://docs.nimboost.com/lib/ruby/kojak
+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.0.6
+signing_key: 
+specification_version: 4
+summary: Kojak is a neat and bald tracer and debug logger.
+test_files:
+- test/dummies/dummy.rb
+- test/minitest_helper.rb
+- test/test_caller.rb
+- test/test_inspector.rb
+- test/test_printer/test_basic.rb
+- test/test_printer/test_colorized.rb
+- test/test_printer/test_nulled.rb
+- test/test_printer/test_randomly_colorized.rb
+- test/test_printer/test_synchronized.rb
+- test/test_top_level.rb