tattletail 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@tattletail --create

data/Gemfile

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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/tattletail/version.rb

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

data/lib/tattletail.rb

@@ -0,0 +1,270 @@
+# -*- encoding: utf-8 -*-
+require 'benchmark'
+require 'colorful'
+require 'tattletail/version'
+
+module Tattletail
+  COLORS = { :count => '00a0b0',
+             :file => '444',
+             :context => '999',
+             :self => '793A57',
+             :method => 'fff',
+             :args => 'EB6841',
+             :result => '2DE04D',
+             :result_yaml => '105023',
+             :time_good => 'EDC951',
+             :time_bad => 'CC333F' }
+
+  def self.reset
+    $_tma_count = 0
+    $_tma_indent = 0
+    $_tma_last_indent = 0
+  end
+
+  def self.inc
+    $_tma_count += 1
+  end
+
+  def self.indent
+    $_tma_indent += 1
+  end
+
+  def self.outdent
+    $_tma_indent -= 1
+  end
+
+  def self.remember_indent
+    $_tma_last_indent = $_tma_indent
+  end
+
+  def self.count
+    $_tma_count ||= 0
+  end
+
+  def self.indent_level
+    $_tma_indent ||= 0
+  end
+
+  def self.indent_changed?
+    $_tma_indent < $_tma_last_indent
+  end
+
+  def self.count_str
+    " ##{count.to_s} ".color(COLORS[:count]).bold
+  end
+
+  def self.self_str passed_self
+    passed_self.to_s.color(COLORS[:self])
+  end
+
+  def self.file_str method_caller
+    file_name, line_number = method_caller[0].split(':', 3)
+    "#{file_name}:#{line_number}".color(COLORS[:file])
+  end
+
+  def self.context_str method_caller
+    file_name, line_number, context = method_caller[0].split(':', 3)
+    begin
+      actual_line = File.readlines(file_name)[line_number.to_i - 1].strip
+    rescue Exception => e
+      actual_line = "Unable to open #{file_name}:#{line_number}"
+    end
+    "#{context} ... #{actual_line}".color(COLORS[:context])
+  end
+
+  def self.method_str method_name, *args
+    name_str = "#{method_name}".bold
+    args_str = "(#{args.map {|a| a.inspect.size > 150 ? a.to_s : a.inspect}.map {|a| a.color(COLORS[:args])}.join(', ')})"
+    name_str + args_str
+  end
+
+  def self.indent_str
+    indent_level.times.inject('') {|m| m += " │ "}
+  end
+
+  def self.start_indent_str
+    indent_str.reverse.sub(" │", "─├").reverse + "─┬─"
+  end
+
+  def self.cont_indent_str
+    "#{indent_str} │ "
+  end
+
+  def self.end_indent_str
+    "#{indent_str} └─"
+  end
+
+  def self.time_str seconds
+    time_str = (' ' * count.to_s.size) + ("%.4f sec" % seconds)
+    seconds > 0.05 ? time_str.color(COLORS[:time_bad]) : time_str.color(COLORS[:time_good])
+  end
+
+  def self.result_str result, indent_str
+    result.to_s.color(COLORS[:result]) + if result.instance_variables.any? && ENV['SHOW_YAML']
+                          "\n" + indent_str + "         " + result.to_yaml.each_line.map do |l|
+                            l.gsub(/\n/,'').color(COLORS[:result_yaml])
+                          end.join("\n").gsub(/\n/, "\n#{indent_str}           ")
+                        else
+                          ''
+                        end
+  end
+
+  def tattle_on(*method_names)
+    method_names.each do |method_name|
+      if class_method? method_name
+        tattle_on_class_method method_name
+      else
+        tattle_on_instance_method method_name
+      end
+    end
+  end
+
+  def tattle_on_class_method(*method_names)
+    method_names.each do |method_name|
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        class << self
+          #{make_talk method_name}
+        end
+      EOS
+    end
+  end
+  alias tattle_on_class_methods tattle_on_class_method
+
+  def tattle_on_instance_method(*method_names)
+    method_names.each do |method_name|
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        #{make_talk method_name}
+      EOS
+    end
+  end
+  alias tattle_on_instance_methods tattle_on_instance_method
+
+private
+
+  def class_method? method_name
+    class_eval { respond_to? method_name }
+  end
+
+  def make_talk method_name
+    original_method = "_quiet_#{method_name}"
+    <<-EOF
+      if method_defined?(:#{original_method})
+        return
+      end
+      alias #{original_method} #{method_name}
+
+      def #{method_name}(*args, &blk)
+        Tattletail.inc
+
+        count_str = Tattletail.count_str
+
+        indent_str = Tattletail.indent_str
+        start_indent_str = Tattletail.start_indent_str
+        cont_indent_str = Tattletail.cont_indent_str
+        end_indent_str = Tattletail.end_indent_str
+
+        method_str = Tattletail.method_str :#{method_name}, *args
+        file_str = Tattletail.file_str(caller)
+        context_str = Tattletail.context_str(caller)
+        self_str = Tattletail.self_str(self)
+
+        if defined?(Rails)
+          file_str.sub!(Rails.root.to_s, '')
+        end
+
+        puts indent_str
+        puts start_indent_str + count_str + self_str + "." + method_str + " called"
+        puts "\#{cont_indent_str}      \#{file_str}"
+        puts "\#{cont_indent_str}        \#{context_str}"
+
+        Tattletail.indent
+        result = nil
+          seconds = Benchmark.realtime { result = #{original_method}(*args, &blk) }
+          time_str = Tattletail.time_str(seconds)
+          result_str = Tattletail.result_str(result, indent_str)
+          Tattletail.outdent
+
+          puts cont_indent_str if Tattletail.indent_changed?
+          puts end_indent_str + count_str + self_str + "." + method_str + " ⊢ " + result_str
+
+          Tattletail.remember_indent
+
+          puts indent_str + "       " + time_str
+
+          result
+      end
+    EOF
+  end
+
+end
+
+Tattletail.reset
+
+class Object
+  extend Tattletail
+end
+
+class Fib
+  def no_args
+    5
+  end
+  tattle_on :no_args
+
+  def fib x
+    return 1 if x <= 2
+    fib(x - 1) + fib(x - 2)
+  end
+  tattle_on_instance_method :fib
+
+  def self.fib x
+    return 1 if x <= 2
+    fib(x - 1) + fib(x - 2)
+  end
+  tattle_on :fib
+
+  def self.find x
+    return 1 if x <= 2
+    find(x - 1) + find(x - 2)
+  end
+  tattle_on :find
+
+  def find x
+    x * 2
+  end
+  tattle_on_instance_method :find
+
+  def fib_block &blk
+    fib yield
+  end
+  tattle_on :fib_block
+end
+
+module Merge
+  extend Tattletail
+
+  def self.sample_array
+    [3,7,5,1,2,9,8,0,2,3,5,2,4,1,6,7,8,4,6,2,1]
+  end
+
+  def self.mergesort(list = sample_array)
+    return list if list.size <= 1
+    mid = list.size / 2
+    left  = list[0, mid]
+    right = list[mid, list.size]
+    merge(mergesort(left), mergesort(right))
+  end
+  tattle_on :mergesort
+
+  def self.merge(left, right)
+    sorted = []
+    until left.empty? or right.empty?
+      if left.first <= right.first
+        sorted << left.shift
+      else
+        sorted << right.shift
+      end
+    end
+    sorted.concat(left).concat(right)
+  end
+  tattle_on :merge
+end

data/tattletail.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tattletail/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tattletail"
+  s.version     = Tattletail::VERSION
+  s.authors     = ["Nick Karpenske"]
+  s.email       = ["randland@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Ruby method call observer}
+  s.description = %q{Provides a method to watch specific methods and print them when they are called}
+
+  s.rubyforge_project = "tattletail"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fuubar"
+  s.add_runtime_dependency "colorful"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: tattletail
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nick Karpenske
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-29 00:00:00.000000000 -05:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157100980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157100980
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: &2157100560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157100560
+- !ruby/object:Gem::Dependency
+  name: colorful
+  requirement: &2157100140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157100140
+description: Provides a method to watch specific methods and print them when they
+  are called
+email:
+- randland@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README
+- Rakefile
+- lib/tattletail.rb
+- lib/tattletail/version.rb
+- tattletail.gemspec
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tattletail
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Ruby method call observer
+test_files: []