letters 0.1.0

data/COPYING

@@ -0,0 +1,20 @@
+Copyright (c) 2012 David Jacobs <http://wit.io>
+
+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 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/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+gem "awesome_print"
+gem "activesupport"
+gem "xml-simple"
+gem "timecop"
+gem "colorize"
+
+if RUBY_VERSION =~ /1\.9\.\d+/
+  gem "debugger"
+else
+  gem "ruby-debug"
+end

data/README.md

@@ -0,0 +1,50 @@
+**Letters** is a little alphabetical library that makes sophisticated debugging easy & fun.
+
+For many of us, troubleshooting begins and ends with the `print` statement. Others recruit the debugger, too. (Maybe you use `print` statements to look at changes over time but the debugger to focus on a small bit of code.) These tools are good, but they are the lowest level of how we can debug in Ruby. Letters leverages `print`, the debugger, control transfer, computer beeps, and other side-effects for more well-rounded visibility into code and state.
+
+### Installation ###
+
+If you're using RubyGems, install Letters with:
+
+    #!plain
+    gem install letters
+
+By default, requiring `"letters"` monkey-patches `Object`. It goes without saying that if you're using Letters in an app that has environments, you probably only want to use it in development.
+
+### Debugging with letters ###
+
+With Letters installed, you have a suite of methods available wherever you want them in your code -- at the end of any expression, in the middle of any pipeline. Most of these methods will output some form of information, though there are more sophisticated ones that pass around control of the application.
+
+Let's start with the `p` method as an example. It is one of the most familiar methods. Calling it prints the receiver to STDOUT and returns the receiver:
+
+    #!ruby
+    { foo: "bar" }.p 
+    # => { foo: "bar" }
+    # prints { foo: "bar" }
+
+That's simple enough, but not really useful. Things get interesting when you're in a pipeline:
+
+    #!ruby
+    words.grep(/interesting/).
+      map(&:downcase).
+      group_by(&:length).
+      values_at(5, 10)
+      slice(0..2).
+      join(", ")
+    
+If I want to know the state of your code after lines 3 and 5, all I have to do is add `.p` to each one:
+
+    #!ruby
+    words.grep(/interesting/).
+      map(&:downcase).
+      group_by(&:length).p.
+      values_at(5, 10)
+      slice(0..2).p.
+      join(", ")
+
+Because the `p` method (and nearly every Letters method) returns the original object, introducing it is only ever for side effects -- it won't change the output of your code.
+
+This is significantly easier than breaking apart the pipeline using variable assignment or a hefty `tap` block.
+
+The `p` method takes options, too, so you can add a prefix message to the output or choose another output format -- like [YAML]() or [pretty print]().
+

data/lib/letters.rb

@@ -0,0 +1,24 @@
+require "letters/patch"
+require "set"
+
+module Letters
+  def self.object_for_diff=(object)
+    @@object = object
+  end
+
+  def self.object_for_diff
+    @@object if defined?(@@object)
+  end
+end
+
+Letters.patch! Numeric
+Letters.patch! Symbol
+Letters.patch! String
+Letters.patch! Regexp
+Letters.patch! Array
+Letters.patch! Set
+Letters.patch! Hash
+Letters.patch! Range
+Letters.patch! NilClass
+Letters.patch! TrueClass
+Letters.patch! FalseClass

data/lib/letters/assertion_error.rb

@@ -0,0 +1,4 @@
+module Letters
+  class AssertionError < RuntimeError
+  end
+end

data/lib/letters/core_ext.rb

@@ -0,0 +1,159 @@
+require "letters/helpers"
+require "letters/assertion_error"
+require "letters/empty_error"
+require "letters/nil_error"
+require "letters/time_formats"
+
+module Letters
+  module CoreExt
+    DELIM = "-" * 20
+
+    # Assert
+    def a(opts={}, &block)
+      opts = { error_class: AssertionError }.merge opts
+      tap do |o|
+        Helpers.message opts
+        if block_given? && !o.instance_eval(&block)
+          raise opts[:error_class]
+        end
+      end
+    end
+
+    # Beep
+    def b
+      tap do
+        $stdout.print "\a"
+      end
+    end
+
+    # Callstack
+    def c(opts={})
+      tap do
+        Helpers.message opts
+        Helpers.out Helpers.pretty_callstack(caller 4), opts
+      end
+    end
+
+    # Debug
+    def d
+      tap do
+        Helpers.call_debugger 
+      end
+    end
+
+    # Diff 1
+    def d1
+      tap do |o|
+        Letters.object_for_diff = o
+      end
+    end
+
+    # Diff 2
+    def d2(opts={})
+      require "awesome_print"
+      opts = { format: "ap" }.merge opts
+      tap do |o|
+        diff = Helpers.diff(Letters.object_for_diff, o)
+        Helpers.message opts
+        Helpers.out diff, opts
+        Letters.object_for_diff = nil
+      end
+    end
+    
+    # Empty check
+    def e(opts={})
+      opts.merge! :error_class => EmptyError
+      tap do |o|
+        Helpers.message opts
+        o.a(opts) { !empty? } 
+      end
+    end
+
+    # File
+    def f(opts={})
+      opts = { format: "yaml", name: "log" }.merge opts
+      tap do |o|
+        File.open(opts[:name], "w+") do |file|
+          # Override :stream
+          opts.merge! :stream => file
+          Helpers.message opts
+          Helpers.out o, opts
+        end
+      end
+    end
+
+    # Jump
+    def j(&block)
+      tap do |o|
+        o.instance_eval &block
+      end
+    end
+
+    # Log
+    def l(opts={})
+      opts = { level: "info", format: "yaml" }.merge opts
+      tap do |o|
+        begin
+          logger.send(opts[:level], opts[:message]) if opts[:message]
+          logger.send(opts[:level], Helpers.send(opts[:format], o))
+        rescue
+          $stdout.puts "[warning] No logger available"
+        end
+      end
+    end
+
+    # Taint and untaint object
+    def m(taint=true)
+      tap do |o|
+        if taint
+          o.taint
+        else
+          o.untaint
+        end
+      end
+    end
+
+    # Nil check
+    def n(opts={})
+      opts.merge! :error_class => NilError
+      tap do |o|
+        o.a(opts) { !nil? } 
+      end
+    end
+
+    # Print to STDOUT
+    def p(opts={}, &block)
+      opts = { format: "ap", stream: $stdout }.merge opts
+      tap do |o|
+        Helpers.message opts
+        obj = block_given? ? o.instance_eval(&block) : o 
+        Helpers.out obj, opts
+      end
+    end
+
+    # RI
+    def r(method=nil)
+      tap do |o|
+        method_or_empty = method ? "##{method}" : method
+        system "ri #{o.class}#{method_or_empty}" 
+      end
+    end
+
+    # Change safety level
+    def s(level=nil)
+      tap do
+        level ||= $SAFE + 1
+        Helpers.change_safety level
+      end
+    end
+
+    # Timestamp
+    def t(opts={})
+      opts = { time_format: "millis" }.merge opts
+      tap do
+        Helpers.message opts
+        Helpers.out Time.now.to_s(opts[:time_format].to_sym), opts
+      end
+    end
+  end
+end

data/lib/letters/empty_error.rb

@@ -0,0 +1,4 @@
+module Letters
+  class EmptyError < RuntimeError 
+  end
+end

data/lib/letters/helpers.rb

@@ -0,0 +1,110 @@
+require "colorize"
+
+module Letters
+  module Helpers
+    def self.diff(obj1, obj2)
+      case obj2
+      when Hash
+        {
+          removed: obj1.reject {|k, v| obj2.include? k },
+          added:   obj2.reject {|k, v| obj1.include? k },
+          updated: obj2.select {|k, v| obj1.include?(k) && obj1[k] != v }
+        }
+      when String
+        diff(obj1.split("\n"), obj2.split("\n"))
+      else
+        { 
+          removed: Array(obj1 - obj2),
+          added: Array(obj2 - obj1)
+        }
+      end
+    rescue
+      raise "cannot diff the two marked objects" 
+    end
+
+    def self.message(opts={})
+      out(opts[:message], opts) if opts[:message]
+    end
+
+    def self.out(object, opts={})
+      opts = { stream: $stdout, format: "string" }.merge opts
+      opts[:stream].puts Helpers.send(opts[:format], object)
+    end
+
+    def self.ap(object)
+      require "awesome_print"
+      object.awesome_inspect
+    end
+
+    def self.json(object)
+      require "json"
+      object.to_json
+    end
+
+    def self.pp(object)
+      require "pp"
+      object.pretty_inspect
+    end
+
+    def self.string(object)
+      object.to_s
+    end
+
+    def self.xml(object)
+      require "xmlsimple"
+      XmlSimple.xml_out(object, { "KeepRoot" => true })
+    end
+
+    def self.yaml(object)
+      require "yaml"
+      object.to_yaml
+    end
+
+    def self.pretty_callstack(callstack)
+      home = ENV["MY_RUBY_HOME"]
+
+      parsed = callstack.map do |entry|
+        line, line_no, method_name = entry.split ":"
+
+        {
+          line: line.gsub(home + "/", "").green,
+          line_no: line_no.yellow,
+          method_name: method_name.scan(/`([^\']+)'/).first.first.light_blue
+        }
+      end
+
+      headers = {
+        line: "Line".green,
+        line_no: "No.".yellow,
+        method_name: "Method".light_blue
+      }
+
+      parsed.unshift headers
+
+      longest_line = 
+        parsed.map {|entry| entry[:line] }.
+          sort_by(&:length).
+          last
+
+      longest_method = 
+        parsed.map {|entry| entry[:method_name] }.
+          sort_by(&:length).
+          last
+
+      formatter = "%#{longest_method.length}{method_name} %-#{longest_line.length}{line} %{line_no}\n"
+
+      parsed.map {|h| formatter % h }.join
+    end
+
+    # This provides a mockable method for testing
+    def self.call_debugger
+      require "ruby-debug"
+      debugger
+      nil
+    end
+
+    def self.change_safety(safety)
+      $SAFE = safety
+    end
+  end
+end

data/lib/letters/nil_error.rb

@@ -0,0 +1,4 @@
+module Letters
+  class NilError < RuntimeError
+  end
+end

data/lib/letters/patch.rb

@@ -0,0 +1,14 @@
+require "letters/core_ext"
+
+module Letters
+  def self.patch!(obj)
+    case obj
+    when Class
+      obj.instance_eval do
+        include Letters::CoreExt
+      end
+    when Object
+      obj.extend Letters::CoreExt
+    end
+  end
+end

data/lib/letters/time_formats.rb

@@ -0,0 +1,5 @@
+require "active_support/core_ext/date_time/conversions"
+
+module Letters
+  Time::DATE_FORMATS[:millis] = "%m/%d/%Y %H:%M:%S.%L"
+end

data/lib/letters/version.rb

@@ -0,0 +1,3 @@
+module Letters
+  VERSION = "0.1.0"
+end

data/spec/letters/core_ext_spec.rb

@@ -0,0 +1,250 @@
+require "spec_helper"
+
+module Letters
+  describe CoreExt do
+    let(:hash) { Hash.new }
+
+    before do
+      @old_dir = Dir.getwd
+      FileUtils.mkdir_p "tmp"
+      Dir.chdir "tmp"
+    end
+
+    after do
+      Dir.chdir @old_dir
+      FileUtils.rm_rf "tmp"
+    end
+
+    it "all letter methods but #e and #n return the original object" do
+      # Prevent output and debugging
+      Helpers.should_receive(:call_debugger).any_number_of_times
+      $stdout.should_receive(:puts).any_number_of_times
+      hash.should_receive(:system).any_number_of_times
+      Helpers.should_receive(:change_safety).any_number_of_times
+
+      ("a".."z").to_a.reject do |letter|
+        letter =~ /[ejn]/
+      end.select do |letter|
+        hash.respond_to? letter
+      end.each do |letter|
+        hash.send(letter).should == hash
+      end
+
+      # Methods that can take a block
+      hash.j { nil }.should == hash
+      hash.p { nil }.should == hash
+    end
+
+    describe "#a (assert)" do
+      it "jumps into the receiver's calling context" do
+        lambda do
+          [1, 2, 3].a { count }
+        end.should_not raise_error
+      end
+
+      it "raises a Letters::AssertionError if the block returns false" do
+        lambda do
+          [1, 2, 3].a { count > 3 } 
+        end.should raise_error(Letters::AssertionError)
+      end
+
+      it "raises a Letters::AssertionError if the block returns nil" do
+        lambda do
+          [1, 2, 3].a { nil }
+        end.should raise_error(Letters::AssertionError)
+      end
+
+      it "does nothing if the block returns a truthy value" do
+        [1, 2, 3].a { count < 4 }.should == [1, 2, 3]
+      end
+    end
+
+    describe "#c (callstack)" do
+      it "outputs the current call trace then returns the object" do
+        $stdout.should_receive(:puts).with kind_of String
+        hash.c
+      end
+    end
+
+    describe "#d (debug)" do
+      it "enters the debugger and then returns the object" do
+        Helpers.should_receive(:call_debugger)
+        hash.d
+      end
+    end
+
+    describe "#d1, #d2 (smart object diff)" do
+      it "outputs the difference between two arrays" do
+        arr1, arr2 = [1, 2, 3], [3, 4, 5]
+        expected_diff = Helpers.diff(arr1, arr2)
+        $stdout.should_receive(:puts).with(expected_diff.awesome_inspect).once
+
+        arr1.d1.should == arr1
+        arr2.d2.should == arr2
+      end
+    end
+
+    describe "#e (empty check)" do
+      it "raises an error if the receiver is empty" do
+        lambda { "".e }.should raise_error(EmptyError)
+      end
+
+      it "does nothing if the receiver is not empty" do
+        lambda { "string".e }.should_not raise_error
+        "string".n.should == "string"
+      end
+    end
+
+    describe "#f (file)" do
+      describe "when no filename or output format are given" do
+        it "writes the object as YAML to a file named 'log'" do
+          File.exist?("log").should_not be_true
+          hash.f
+          File.exist?("log").should be_true
+          File.read("log").should == hash.to_yaml
+        end
+      end
+
+      describe "when a file name, but no output format is given" do
+        it "writes the object as YAML to the named file" do
+          hash.f(:name => "object")
+          File.exist?("object").should be_true
+          File.read("object").should == hash.to_yaml
+        end
+      end
+
+      describe "when an output format, but no file name is given" do
+        it "writes the object as that format to a file named 'log'" do
+          hash.f(:format => :ap)
+          File.exist?("log").should be_true
+          File.read("log").chomp.should == hash.awesome_inspect
+        end
+      end
+    end
+
+    describe "#j (jump)" do
+      it "jumps into the object's context" do
+        a = nil
+        hash.j { a = count }
+        a.should == 0
+      end
+
+      it "allows for IO, even in object context" do
+        $stdout.should_receive(:puts).with(0)
+        hash.j { puts count }
+      end
+    end
+
+    describe "#l (log)" do
+      it "logs the object if a logger is present and then returns the object" do
+        logger = double 'logger'
+        logger.should_receive(:info).with(hash.to_yaml)
+        hash.should_receive(:logger).and_return(logger)
+        hash.l
+      end
+
+      it "prints an warning if a logger is not present and then returns the object" do
+        $stdout.should_receive(:puts).with("[warning] No logger available")
+        hash.l
+      end
+
+      it "logs the object if a logger is present and then returns the object" do
+        logger = double 'logger'
+        logger.should_receive(:info).never
+        logger.should_receive(:error).with(hash.to_yaml)
+        hash.should_receive(:logger).and_return(logger)
+        hash.l(:level => "error")
+      end
+    end
+
+    describe "#m (mark object as tainted/untainted)" do
+      it "with no argument or `true`, marks the receiver as tainted" do
+        lambda do
+          hash.m
+        end.should change { hash.tainted? }.from(false).to(true)
+      end
+
+      it "when passed `false`, marks the receiver as untainted" do
+        hash.taint
+        lambda do
+          hash.m(false)
+        end.should change { hash.tainted? }.from(true).to(false)
+      end
+    end
+
+    describe "#n (nil check)" do
+      it "raises an error if the receiver is nil" do
+        lambda { nil.n }.should raise_error(NilError)
+      end
+
+      it "does nothing if the receiver is not nil" do
+        lambda { hash.n }.should_not raise_error
+      end
+    end
+
+    describe "#p (print)" do
+      describe "when no format is given" do
+        it "writes the object as awesome_print to STDOUT" do
+          $stdout.should_receive(:puts).with(hash.awesome_inspect)
+          hash.p
+        end
+      end
+
+      describe "when a format is given" do
+        it "writes the object as that format to STDOUT" do
+          $stdout.should_receive(:puts).with(hash.to_yaml)
+          hash.p(:format => :yaml)
+        end
+      end
+
+      describe "when a block is given" do
+        it "write the result of the block, executed in the object's context" do
+          $stdout.should_receive(:puts).with(hash.length.awesome_inspect)
+          hash.p { length }.should == hash
+        end
+      end
+    end
+
+    describe "#r (ri)" do
+      it "displays RI information for the receiver's class, if available" do
+        hash.should_receive(:system).with("ri Hash")
+        hash.r
+      end
+
+      it "can narrow its scope to a single method" do
+        hash.should_receive(:system).with("ri Hash#new")
+        hash.r(:new)
+      end
+    end
+
+    describe "#s (safety)" do
+      it "without argument, bumps the safety level by one" do
+        Helpers.should_receive(:change_safety).with(1)
+        hash.s
+      end
+
+      it "bumps the safety level to the specified level if possible" do
+        Helpers.should_receive(:change_safety).with(4)
+        hash.s(4)
+      end
+
+      it "throws an exception if the specified level is invalid" do
+        # Simulate changing safety level from higher level
+        Helpers.should_receive(:change_safety).with(3).and_raise
+        lambda do
+          hash.s(3)
+        end.should raise_error
+      end
+    end
+
+    describe "#t (timestamp)" do
+      it "without :stream, prints the current time to STDOUT" do
+        time = Time.now
+        Timecop.freeze(time) do
+          $stdout.should_receive(:puts).with(time.to_s(:millis)).twice
+          {}.t.select {|k,v| k =~ /foo/ }.t
+        end
+      end
+    end
+  end
+end

data/spec/letters/helpers_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+module Letters
+  describe Helpers do
+    let(:hash) { Hash.new }
+
+    describe ".diff" do
+      it "returns the difference between two arrays" do
+        array1 = [1, 2, 3]
+        array2 = [3, 4, 5]
+        Helpers.diff(array1, array2).should == {
+          removed: [1, 2],
+          added: [4, 5]
+        }
+      end
+
+      it "returns the difference between two hashes" do
+        hash1 = { a: "foo", b: "bar" }
+        hash2 = { b: "baz", c: "bat" }
+
+        Helpers.diff(hash1, hash2).should == {
+          removed: { a: "foo" },
+          added: { c: "bat" },
+          updated: { b: "baz" }
+        }
+      end
+
+      it "returns the difference between two sets" do
+        set1 = Set.new([1, 2, 3])
+        set2 = Set.new([3, 4, 5])
+        Helpers.diff(set1, set2).should == {
+          removed: [1, 2],
+          added: [4, 5]
+        }
+      end
+
+      it "returns the difference between two strings" do
+        string1 = "Line 1\nLine 2" 
+        string2 = "Line 1 modified\nLine 2\nLine 3"
+        Helpers.diff(string1, string2).should == {
+          removed: ["Line 1"],
+          added: ["Line 1 modified", "Line 3"]
+        }
+      end
+
+      it "returns the difference between two objects of the same hierarchy" do
+        DiffableClass = Class.new do
+          attr_accessor :vals
+
+          def initialize(vals)
+            self.vals = vals
+          end
+
+          def -(other)
+            vals - other.vals
+          end
+        end
+
+        dc1 = DiffableClass.new([1, 2, 3])
+        dc2 = DiffableClass.new([3, 4, 5])
+        Helpers.diff(dc1, dc2).should == {
+          removed: [1, 2],
+          added: [4, 5]
+        }
+      end
+
+      it "throws an exception if the objects are not of the same type" do
+        lambda do
+          Helpers.diff(Object.new, Hash.new)
+        end.should raise_error
+      end
+    end
+
+    describe ".awesome_print" do
+      it "outputs the YAML representation of the object then returns the object" do
+        Helpers.ap(hash).should == "{}"
+      end
+    end
+
+    describe ".pretty_print" do
+      it "outputs the pretty-print representation of the object and then returns the object" do
+        Helpers.pp(hash).should == "{}\n"
+      end
+    end
+
+    describe ".string" do
+      it "outputs the representation of the object returned by #to_s" do
+        complex_hash = { foo: "bar", baz: [1, 2, 3] }
+        Helpers.string(complex_hash).should == complex_hash.to_s
+      end
+    end
+
+    describe ".xml" do
+      it "outputs the XML representation of the object and then returns the object" do
+        Helpers.xml(hash).should == "<opt></opt>\n"
+      end
+    end
+
+    describe ".yaml" do
+      it "outputs the YAML representation of the object and then returns the object" do
+        Helpers.yaml(hash).strip.should == "--- {}"
+      end
+    end
+  end
+end

data/spec/letters/patch_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module Letters
+  describe ".patch!" do
+    before do
+      # Hide output
+      $stdout.should_receive(:puts)
+    end
+
+    it "adds Letters::CoreExt to classes" do
+      Klass = Class.new
+      Letters.patch! Klass
+      k = Klass.new
+      k.p.should == k
+    end
+
+    it "adds Letters::CoreExt to objects" do
+      obj = Object.new
+      Letters.patch! obj
+      obj.p.should == obj
+    end
+  end
+end

data/spec/letters/time_formats_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+module Letters
+  describe "time formats" do
+    it "allows for easy manipulation of timestamp displays" do
+      Time.utc(2012, "jan", 1, 13, 15, 1).tap do |time|
+        time.to_s(:millis).should == "01/01/2012 13:15:01.000"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "letters"
+require "awesome_print"
+require "timecop"

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: letters
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- David Jacobs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: &70179670061620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179670061620
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70179670061180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179670061180
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: &70179670060760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179670060760
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: &70179670060340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179670060340
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: &70179670059920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179670059920
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70179670091740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70179670091740
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70179670091320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70179670091320
+description: Letters brings Ruby debugging into the 21st century. It leverages print,
+  the debugger, control transfer, even computer beeps to let you see into your code's
+  state.
+email: david@wit.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/letters/assertion_error.rb
+- lib/letters/core_ext.rb
+- lib/letters/empty_error.rb
+- lib/letters/helpers.rb
+- lib/letters/nil_error.rb
+- lib/letters/patch.rb
+- lib/letters/time_formats.rb
+- lib/letters/version.rb
+- lib/letters.rb
+- README.md
+- COPYING
+- Gemfile
+- spec/letters/core_ext_spec.rb
+- spec/letters/helpers_spec.rb
+- spec/letters/patch_spec.rb
+- spec/letters/time_formats_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/davejacobs/letters
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A tiny debugging library for Ruby
+test_files:
+- spec/letters/core_ext_spec.rb
+- spec/letters/helpers_spec.rb
+- spec/letters/patch_spec.rb
+- spec/letters/time_formats_spec.rb
+- spec/spec_helper.rb