Module: Dumps

Defined in:
lib/dumps.rb,
lib/dumps/version.rb

Defined Under Namespace

Modules: Dump__ClassMethods

Constant Summary collapse

VERSION = 
"1.0.0"

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.dp(object) ⇒ Object 



10
 
# File 'lib/dumps.rb', line 10

def self.dp(object) = $stderr.puts object.inspect

.dputs(object = "") ⇒ Object 



11
 
# File 'lib/dumps.rb', line 11

def self.dputs(object = "") = $stderr.puts object

.dump(object, *args, **opts) ⇒ Object

:call-seq:

dump(object, label|ident|index|range..., new: false, exclude: nil)

::dump also supports an :index option but it is only meant to be used internally



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/dumps.rb', line 33

def self.dump(object, *args, **opts)
  constrain args, [String, Symbol, Integer, Range, nil]
  constrain object.is_a?(Dumps) || opts.slice(:new, :exclude).empty?, true
  label = args.select { |arg| arg.nil? || arg.is_a?(String) }.last
  idents = args.select { |arg| arg.is_a?(Symbol) }
  indexes = args.select { |arg| arg.is_a?(Integer) || arg.is_a?(Range) }
  idents.empty? || indexes.empty? or raise ArgumentError, "Symbols and Integers can't be combined"
  
  # Register if this is an anonymous top-level call to ::dump (ie. the first
  # #dump method to be called from the application)
  self.anonymous = label.nil? if empty?

  case object
    when Array; dump_array(object, label, *indexes)
    when Hash; dump_hash(object, label, *idents)
    when Dumps; dump_object(object, label, *idents, **opts)
  else
    idents.empty? or raise ArgumentError
    Dumps.dump_label(label, false); dump_value(object)
  end
end

.dump_array(array, label, *indexes, **opts) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/dumps.rb', line 60

def self.dump_array(array, label, *indexes, **opts)
  constrain array, Array
  constrain indexes, [Integer, Range]
  indexes = 
      if indexes.empty?
        array.each_index
      else
        indexes.map { |e|
          e.is_a?(Range) ? e.each.to_a : e
        }.flatten
      end
  context(array, label, **opts) {
    dump_label(label)
    level = label ? 1 : 0
    indent(level) { 
      indexes.each { |i| print "- "; indent(bol: false) { dump(array[i], index: i) } }
    }
  }
end

.dump_hash(hash, label, *idents, **opts) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/dumps.rb', line 80

def self.dump_hash(hash, label, *idents, **opts)
  constrain hash, Hash
  constrain idents, [Symbol]
  keys = idents.empty? ? hash.keys : idents
  context(hash, label, **opts) {
    dump_label(label)
    level = label ? 1 : 0
    indent(level) { 
      keys.each { |key| dump(hash[key], key.to_s) }
    }
  }
end

.dump_id(object) ⇒ Object 



146
147
148
149
150
151
152
 
# File 'lib/dumps.rb', line 146

def self.dump_id(object)
  if object.class.to_s.start_with?("#")
    puts "<#{object.object_id}> (Class@<#{object.class.object_id}>)"
  else
    puts "<#{object.object_id}> (#{object.class})"
  end
end

.dump_label(label, newline = true) ⇒ Object 



55
56
57
58
 
# File 'lib/dumps.rb', line 55

def self.dump_label(label, newline = true)
  constrain label, String, nil
  print "#{label}:#{newline ? "\n" : " "}" if label
end

.dump_object(object, label, *idents, new: false, exclude: nil, **opts) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/dumps.rb', line 93

def self.dump_object(object, label, *idents, new: false, exclude: nil, **opts)
  constrain object, Dumps
  constrain label, String, nil
  constrain idents, [Symbol]
  constrain new, false, true
  constrain exclude, nil, [Symbol]
  idents = (new ? [] : object.class.dump_identifiers) \
         + idents \
         - (exclude.nil? ? [] : exclude)
  idents.uniq!
  if idents.empty?
    context(object, label, **opts) { dump_label(label, false); dump_id(object) }
  else
    context(object, label, **opts) {
      dump_label(label)
      level = label ? 1 : 0
      indent(level) {
        idents.each { |ident|
          attr_method = :"dump_attr_#{ident}"
          value_method = :"dump_value_#{ident}"

          if overrides?(object, attr_method)
            object.send(attr_method)
          elsif overrides?(object, :dump_attr)
            object.send(:dump_attr, ident)
          elsif overrides?(object, value_method)
            value = capture { object.send(value_method) }
            newline = value =~ /\n./
            dump_label(ident.to_s, newline)
            print value
          elsif overrides?(object, :dump_value)
            value = capture { object.send(:dump_value, ident) }
            newline = value =~ /\n./
            dump_label(ident.to_s, newline)
            print value
          else
            dump(object.send(ident), ident.to_s)
          end
        } 
      }
    }
  end    
end

.dump_reference(object) ⇒ Object 



154
 
# File 'lib/dumps.rb', line 154

def self.dump_reference(object) = puts reference(object)

.dump_value(value) ⇒ Object 



137
138
139
140
141
142
143
144
 
# File 'lib/dumps.rb', line 137

def self.dump_value(value)
  case value
    when Time; puts value.strftime(timezone? ? "%F %T (%z)" : "%F %T")
    when Date; puts value.strftime("%F")
  else
    puts value.inspect
  end
end

.dumps ⇒ Object

The eponymic method of the Dumps module. It is actually just a method for the lazy developer in the tcase where dumps should be seperated by a blank line to enhance readability



25
 
# File 'lib/dumps.rb', line 25

def self.dumps(...) dump(...); puts end

.overrides?(object, method) ⇒ Boolean

Returns:

  • (Boolean) 


165
166
167
 
# File 'lib/dumps.rb', line 165

def self.overrides?(object, method)
  object.respond_to?(method) && object.method(method).owner != Dumps
end

.timezone=(b) ⇒ Object

Enable/disable time zone in timestamps. Default is disabled



14
15
16
17
 
# File 'lib/dumps.rb', line 14

def self.timezone=(b)
  constrain b, TrueClass, FalseClass
  @@timezone = b
end

.timezone? ⇒ Boolean

Returns the current time

Returns:

  • (Boolean) 


20
 
# File 'lib/dumps.rb', line 20

def self.timezone? = @@timezone

Instance Method Details

#dump ⇒ Object

Object-level versions of the class methods



157
 
# File 'lib/dumps.rb', line 157

def dump(...) = Dumps.dump(self, ...)

#dump_id ⇒ Object 



162
 
# File 'lib/dumps.rb', line 162

def dump_id(...) = Dumps.dump_id(self, ...)

#dump_reference ⇒ Object 



163
 
# File 'lib/dumps.rb', line 163

def dump_reference(...) = Dumps.dump_reference(self, ...)

#dump_value(ident) ⇒ Object

def dump_attr <- doesn’t exist here, can be defined in derived classes



161
 
# File 'lib/dumps.rb', line 161

def dump_value(ident) = Dumps.dump_value(self.send(ident))

#dumps ⇒ Object 



158
 
# File 'lib/dumps.rb', line 158

def dumps(...) = Dumps.dumps(self, ...)