Handle circular dependencies. We don't need to log deeper than 3 levels.

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lines (0.1.16)
+    lines (0.1.18)
 
 GEM
   remote: http://rubygems.org/
@@ -26,6 +26,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  bundler (~> 1.3)
   lines!
   parslet
   rdoc

lib/lines.rb

@@ -237,16 +237,24 @@ def map(klass, &rule)
       @mapping[klass] = rule
     end
 
+    attr_accessor :max_depth
+
     protected
 
     attr_reader :mapping
 
     def initialize
       @mapping = {}
+      @max_depth = 3
     end
 
-    def objenc_internal(x)
-      x.map{|k,v| "#{keyenc(k)}=#{valenc(v)}" }.join(' ')
+    def objenc_internal(x, depth=0)
+      depth += 1
+      if depth > max_depth
+        '...'
+      else
+        x.map{|k,v| "#{keyenc(k)}=#{valenc(v, depth)}" }.join(' ')
+      end
     end
 
     def keyenc(k)
@@ -257,10 +265,10 @@ def keyenc(k)
       end
     end
 
-    def valenc(x)
+    def valenc(x, depth)
       case x
-      when Hash           then objenc(x)
-      when Array          then arrenc(x)
+      when Hash           then objenc(x, depth)
+      when Array          then arrenc(x, depth)
       when String, Symbol then strenc(x)
       when Numeric        then numenc(x)
       when Time, Date     then timeenc(x)
@@ -272,16 +280,19 @@ def valenc(x)
       end
     end
 
-    def objenc(x)
-      '{' + objenc_internal(x) + '}'
+    def objenc(x, depth)
+      '{' + objenc_internal(x, depth) + '}'
     end
 
-    def arrenc(a)
+    def arrenc(a, depth)
+      depth += 1
       # num + unit. Eg: 3ms
       if a.size == 2 && a.first.kind_of?(Numeric) && is_literal?(a.last.to_s)
         numenc(a.first) + strenc(a.last)
+      elsif depth > max_depth
+        '[...]'
       else
-        '[' + a.map{|x| valenc(x)}.join(' ') + ']'
+        '[' + a.map{|x| valenc(x, depth)}.join(' ') + ']'
       end
     end
 

spec/lines_spec.rb

@@ -124,6 +124,12 @@ def expect_dump(obj)
     expect_dump(foo: [3, :ms]).to eq('foo=3ms')
     expect_dump(foo: [54.2, 's']).to eq('foo=54.2s')
   end
+
+  it "knows how to handle circular dependencies" do
+    x = {}
+    x[:x] = x
+    expect_dump(x).to eq('x={x={x={...}}}')
+  end
 end
 
 describe Lines::UniqueIDs do