gibbler 0.9.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/lib/gibbler.rb CHANGED
@@ -1,38 +1,26 @@
1
- unless defined?(GIBBLER_LIB_HOME)
2
- GIBBLER_LIB_HOME = File.expand_path File.dirname(__FILE__)
3
- end
1
+ # frozen_string_literal: true
4
2
 
5
- %w{attic}.each do |dir|
6
- $:.unshift File.join(GIBBLER_LIB_HOME, '..', '..', dir, 'lib')
3
+ unless defined?(GIBBLER_LIB_HOME)
4
+ GIBBLER_LIB_HOME = File.expand_path File.dirname(__FILE__)
7
5
  end
8
6
 
9
- require 'thread'
10
7
  require 'attic'
11
8
  require 'digest/sha1'
12
9
 
10
+
13
11
  # = Gibbler
14
- #
12
+ #
15
13
  # "Hola, Tanneritos"
16
14
  #
17
15
  class Gibbler < String
18
- module VERSION
19
- def self.to_s
20
- load_config
21
- [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
22
- end
23
- alias_method :inspect, :to_s
24
- def self.load_config
25
- require 'yaml'
26
- @version ||= YAML.load_file(::File.join(GIBBLER_LIB_HOME, '..', 'VERSION.yml'))
27
- end
28
- end
29
-
16
+
17
+
30
18
  @default_base = 16
31
19
  @secret = nil
32
20
  class << self
33
21
  attr_accessor :secret, :default_base
34
22
  end
35
-
23
+
36
24
  class Error < RuntimeError
37
25
  def initialize(obj); @obj = obj; end
38
26
  end
@@ -44,37 +32,37 @@ end
44
32
  # few digest related convenience methods.
45
33
  #
46
34
  class Gibbler::Digest < String
47
-
35
+
48
36
  module InstanceMethods
49
- # Return an integer assuming base is Gibbler.default_base.
37
+ # Return an integer assuming base is Gibbler.default_base.
50
38
  def to_i(base=nil)
51
39
  base ||= Gibbler.default_base
52
40
  super(base)
53
41
  end
54
-
55
- # Returns a string. Takes an optional base.
42
+
43
+ # Returns a string. Takes an optional base.
56
44
  def to_s(base=nil)
57
45
  base.nil? ? super() : super().to_i(Gibbler.default_base).to_s(base)
58
46
  end
59
-
47
+
60
48
  def base(base=Gibbler.default_base)
61
49
  v = self.to_i(Gibbler.default_base).to_s(base)
62
50
  v.extend Gibbler::Digest::InstanceMethods
63
51
  self.class.new v
64
52
  end
65
-
53
+
66
54
  def base36
67
55
  base(36)
68
56
  end
69
-
70
- # Shorten the digest to the given (optional) length.
57
+
58
+ # Shorten the digest to the given (optional) length.
71
59
  def shorten(len=20)
72
60
  self[0..len-1]
73
61
  end
74
-
62
+
75
63
  # Returns the first 8 characters of itself (the digest).
76
64
  #
77
- # e.g.
65
+ # e.g.
78
66
  #
79
67
  # "kimmy".gibbler # => c8027100ecc54945ab15ddac529230e38b1ba6a1
80
68
  # "kimmy".gibbler.short # => c8027100
@@ -82,10 +70,10 @@ class Gibbler::Digest < String
82
70
  def short
83
71
  shorten(8)
84
72
  end
85
-
73
+
86
74
  # Returns the first 6 characters of itself (the digest).
87
75
  #
88
- # e.g.
76
+ # e.g.
89
77
  #
90
78
  # "kimmy".gibbler # => c8027100ecc54945ab15ddac529230e38b1ba6a1
91
79
  # "kimmy".gibbler.shorter # => c80271
@@ -93,10 +81,10 @@ class Gibbler::Digest < String
93
81
  def shorter
94
82
  shorten(6)
95
83
  end
96
-
84
+
97
85
  # Returns the first 4 characters of itself (the digest).
98
86
  #
99
- # e.g.
87
+ # e.g.
100
88
  #
101
89
  # "kimmy".gibbler # => c8027100ecc54945ab15ddac529230e38b1ba6a1
102
90
  # "kimmy".gibbler.tiny # => c802
@@ -104,7 +92,7 @@ class Gibbler::Digest < String
104
92
  def tiny
105
93
  shorten(4)
106
94
  end
107
-
95
+
108
96
  # Returns true when +ali+ matches +self+
109
97
  #
110
98
  # "kimmy".gibbler == "c8027100ecc54945ab15ddac529230e38b1ba6a1" # => true
@@ -114,7 +102,7 @@ class Gibbler::Digest < String
114
102
  return true if self.to_s == ali.to_s
115
103
  false
116
104
  end
117
-
105
+
118
106
  # Returns true when +g+ matches one of: +self+, +short+, +shorter+, +tiny+
119
107
  #
120
108
  # "kimmy".gibbler === "c8027100ecc54945ab15ddac529230e38b1ba6a1" # => true
@@ -132,45 +120,44 @@ end
132
120
 
133
121
  class Gibbler < String
134
122
  module Object
135
-
123
+
136
124
  def self.included(obj)
137
125
  obj.extend Attic
138
126
  obj.attic :gibbler_cache
139
- # Backwards compatibility for <= 0.6.2
140
- obj.send :alias_method, :__gibbler_cache, :gibbler_cache
141
127
  end
142
-
128
+
143
129
  def self.gibbler_fields
144
130
  end
145
131
  def gibbler_fields
146
132
  end
147
-
148
- # Calculates a digest for the current object instance.
133
+
134
+ # Calculates a digest for the current object instance.
149
135
  # Objects that are a kind of Hash or Array are processed
150
- # recursively. The length of the returned String depends
136
+ # recursively. The length of the returned String depends
151
137
  # on the digest type. Also stores the value in the attic.
152
- #
138
+ #
153
139
  # obj.gibbler # => a5b1191a
154
140
  # obj.gibbler_cache # => a5b1191a
155
- #
141
+ #
156
142
  # Calling gibbler_cache returns the most recent digest
157
143
  # without calculation.
158
144
  #
159
145
  # If the object is frozen, this will return the value of
160
- # <tt>gibbler_cache</tt>.
146
+ # `gibbler_cache`.
161
147
  #
162
148
  def gibbler(digest_type=nil)
163
149
  #gibbler_debug caller[0]
164
150
  gibbler_debug :GIBBLER, self.class, self
165
- return self.gibbler_cache if self.frozen?
166
- self.gibbler_cache = Gibbler::Digest.new self.__gibbler(digest_type)
151
+ ret = Gibbler::Digest.new self.__gibbler(digest_type)
152
+ self.gibbler_cache = ret unless self.frozen?
153
+ ret
167
154
  end
168
155
 
169
156
  # Has this object been modified?
170
157
  #
171
- # This method compares the return value from digest with the
158
+ # This method compares the return value from digest with the
172
159
  # previous value returned by gibbler (the value is stored in
173
- # the attic as <tt>gibbler_cache</tt>).
160
+ # the attic as `gibbler_cache`).
174
161
  # See Attic[http://github.com/delano/attic]
175
162
  def gibbled?
176
163
  self.gibbler_cache ||= self.gibbler
@@ -183,15 +170,15 @@ class Gibbler < String
183
170
  return unless Gibbler.debug?
184
171
  p args
185
172
  end
186
-
173
+
187
174
  # Creates a digest for the current state of self based on:
188
175
  # * Object#class
189
176
  # * Length of Object#name || 0
190
177
  # * Object#name || ''
191
- #
192
- # e.g. Digest::SHA1.hexdigest "Class:6:Object" #=>
193
178
  #
194
- # <b>This is a default method appropriate for only the most
179
+ # e.g. Digest::SHA1.hexdigest "Class:6:Object" #=>
180
+ #
181
+ # <b>This is a default method appropriate for only the most
195
182
  # basic objects like Class and Module.</b>
196
183
  #
197
184
  def __gibbler(digest_type=nil)
@@ -202,10 +189,10 @@ class Gibbler < String
202
189
  gibbler_debug klass, a, [klass, nom.size, nom]
203
190
  a
204
191
  end
205
-
192
+
206
193
  # A simple override on Object#freeze to create a digest
207
194
  # before the object is frozen. Once the object is frozen
208
- # <tt>obj.gibbler</tt> will return the cached value with
195
+ # `obj.gibbler` will return the cached value with
209
196
  # out calculation.
210
197
  def freeze()
211
198
  gibbler_debug :FREEZE, self.class, caller[0] if Gibbler.debug?
@@ -213,9 +200,9 @@ class Gibbler < String
213
200
  super
214
201
  self
215
202
  end
216
-
203
+
217
204
  end
218
-
205
+
219
206
  end
220
207
 
221
208
  class Gibbler < String
@@ -226,7 +213,7 @@ class Gibbler < String
226
213
  # Creates a digest from the given +input+. See Gibbler.digest.
227
214
  #
228
215
  # If only one argument is given and it's a digest, this will
229
- # simply create an instance of that digest. In other words,
216
+ # simply create an instance of that digest. In other words,
230
217
  # it won't calculate a new digest based on that input.
231
218
  def initialize *input
232
219
  if input.size == 1 && Gibbler::Digest::InstanceMethods === input.first
@@ -235,15 +222,15 @@ class Gibbler < String
235
222
  input.collect!(&:to_s)
236
223
  super Gibbler.digest(input) || ''
237
224
  end
238
- end
225
+ end
239
226
  def digest_type
240
227
  @digest_type || self.class.digest_type
241
228
  end
242
-
229
+
243
230
  def digest *input
244
231
  replace Gibbler.digest(input, digest_type)
245
232
  end
246
-
233
+
247
234
  end
248
235
 
249
236
  class Gibbler < String
@@ -251,11 +238,11 @@ class Gibbler < String
251
238
  @debug = false
252
239
  @digest_type = ::Digest::SHA1
253
240
  @delimiter = ':'
254
-
241
+
255
242
  class << self
256
- # Specify a different digest class. The default is +Digest::SHA1+. You
257
- # could try +Digest::SHA256+ by doing this:
258
- #
243
+ # Specify a different digest class. The default is +Digest::SHA1+. You
244
+ # could try +Digest::SHA256+ by doing this:
245
+ #
259
246
  # Object.digest_type = Digest::SHA256
260
247
  #
261
248
  attr_accessor :digest_type
@@ -267,11 +254,11 @@ class Gibbler < String
267
254
  # Returns the current debug status (true or false)
268
255
  def debug?; @debug != false; end
269
256
  end
270
-
257
+
271
258
  # Sends +input+ to Digest::SHA1.hexdigest. If another digest class
272
- # has been specified, that class will be used instead.
259
+ # has been specified, that class will be used instead.
273
260
  # If Gibbler.secret is set, +str+ will be prepended with the
274
- # value.
261
+ # value.
275
262
  #
276
263
  # If +input+ is an Array, it will be flattened and joined.
277
264
  #
@@ -285,12 +272,12 @@ class Gibbler < String
285
272
  dig = dig.to_i(16).to_s(Gibbler.default_base) if 16 != Gibbler.default_base
286
273
  dig
287
274
  end
288
-
275
+
289
276
  def self.gibbler_debug(*args)
290
277
  return unless Gibbler.debug?
291
278
  p args
292
279
  end
293
-
280
+
294
281
  # Raises an exception. The correct usage is to include a Gibbler::Object:
295
282
  # * Gibbler::Complex
296
283
  # * Gibbler::String
@@ -299,20 +286,20 @@ class Gibbler < String
299
286
  def self.included(obj)
300
287
  raise "You probably want to include Gibbler::Complex or Gibbler::Object"
301
288
  end
302
-
303
-
304
- # Creates a digest based on:
305
- # * An Array of instance variable names or method names and values in the format: <tt>CLASS:LENGTH:VALUE</tt>
306
- # * The gibbler method is called on each element so if it is a Hash or Array etc it
289
+
290
+
291
+ # Creates a digest based on:
292
+ # * An Array of instance variable names or method names and values in the format: `CLASS:LENGTH:VALUE`
293
+ # * The gibbler method is called on each element so if it is a Hash or Array etc it
307
294
  # will be parsed recursively according to the gibbler method for that class type.
308
- # * Digest the Array of digests
309
- # * Return the digest for <tt>class:length:value</tt> where:
295
+ # * Digest the Array of digests
296
+ # * Return the digest for `class:length:value` where:
310
297
  # * "class" is equal to the current object class (e.g. FullHouse).
311
298
  # * "length" is the size of the Array of digests (which should equal
312
299
  # the number of instance variables in the object).
313
300
  # * "value" is the Array of digests joined with a colon (":").
314
301
  #
315
- # This method can be used by any class which stores values in instance variables.
302
+ # This method can be used by any class which stores values in instance variables.
316
303
  #
317
304
  # class Episodes
318
305
  # include Gibbler::Complex
@@ -321,7 +308,7 @@ class Gibbler < String
321
308
  #
322
309
  module Complex
323
310
  include Gibbler::Object
324
-
311
+
325
312
  def self.included(obj)
326
313
  obj.extend Attic
327
314
  obj.attic :gibbler_cache
@@ -343,7 +330,7 @@ class Gibbler < String
343
330
  end
344
331
  end
345
332
  end
346
-
333
+
347
334
  def gibbler_fields
348
335
  f = [self.class.gibbler_fields].compact.flatten
349
336
  if f.empty?
@@ -353,8 +340,8 @@ class Gibbler < String
353
340
  end
354
341
  f
355
342
  end
356
-
357
- # Creates a digest for the current state of self.
343
+
344
+ # Creates a digest for the current state of self.
358
345
  def __gibbler(digest_type=nil)
359
346
  klass = self.class
360
347
  d = []
@@ -372,7 +359,7 @@ class Gibbler < String
372
359
  gibbler_debug klass, a, [klass, d.size, d]
373
360
  a
374
361
  end
375
-
362
+
376
363
  def __gibbler_revert!
377
364
  state = self.gibbler_object self.gibbler_cache
378
365
  state.instance_variables do |n|
@@ -381,31 +368,31 @@ class Gibbler < String
381
368
  end
382
369
  end
383
370
  end
384
-
385
- # Creates a digest based on: <tt>CLASS:LENGTH:VALUE</tt>.
386
- # This method can be used for any class where the <tt>to_s</tt>
387
- # method returns an appropriate unique value for this instance.
388
- # It's used by default for Symbol, Class, Fixnum, and Bignum.
371
+
372
+ # Creates a digest based on: `CLASS:LENGTH:VALUE`.
373
+ # This method can be used for any class where the `to_s`
374
+ # method returns an appropriate unique value for this instance.
375
+ # It's used by default for Symbol, Class, Integer.
389
376
  # e.g.
390
- #
377
+ #
391
378
  # "str" => String:3:str => 509a839ca1744c72e37759e7684ff0daa3b61427
392
379
  # :sym => Symbol:3:sym => f3b7b3ca9529002c6826b1ef609d3583c356c8c8
393
380
  #
394
381
  # To use use method in other classes simply:
395
382
  #
396
- # class MyStringLikeClass
383
+ # class MyStringLikeClass
397
384
  # include Gibbler::String
398
385
  # end
399
386
  #
400
387
  module String
401
388
  include Gibbler::Object
402
-
389
+
403
390
  def self.included(obj)
404
391
  obj.extend Attic
405
392
  obj.attic :gibbler_cache
406
393
  end
407
-
408
- # Creates a digest for the current state of self.
394
+
395
+ # Creates a digest for the current state of self.
409
396
  def __gibbler(digest_type=nil)
410
397
  klass = self.class
411
398
  value = self.nil? ? "\0" : self.to_s
@@ -414,81 +401,81 @@ class Gibbler < String
414
401
  a
415
402
  end
416
403
  end
417
-
418
- # Creates a digest based on:
419
- # * parse each key, value pair into an Array containing keys: <tt>CLASS:KEY:VALUE.__gibbler</tt>
420
- # * The gibbler method is called on each element so if it is a Hash or Array etc it
404
+
405
+ # Creates a digest based on:
406
+ # * parse each key, value pair into an Array containing keys: `CLASS:KEY:VALUE.__gibbler`
407
+ # * The gibbler method is called on each element so if it is a Hash or Array etc it
421
408
  # will be parsed recursively according to the gibbler method for that class type.
422
- # * Digest the Array of digests
423
- # * Return the digest for <tt>class:length:value</tt> where:
409
+ # * Digest the Array of digests
410
+ # * Return the digest for `class:length:value` where:
424
411
  # * "class" is equal to the current object class (e.g. Hash).
425
412
  # * "length" is the size of the Array of digests (which should equal
426
413
  # the number of keys in the original Hash object).
427
414
  # * "value" is the Array of digests joined with a colon (":").
428
415
  #
429
- # This method can be used by any class with a <tt>keys</tt> method.
416
+ # This method can be used by any class with a `keys` method.
430
417
  #
431
418
  # class MyOrderedHash
432
419
  # include Gibbler::Hash
433
420
  # end
434
421
  #
435
- module Hash
422
+ module Hash
436
423
  include Gibbler::Object
437
-
424
+
438
425
  def self.included(obj)
439
426
  obj.extend Attic
440
427
  obj.attic :gibbler_cache
441
428
  end
442
-
443
- # Creates a digest for the current state of self.
429
+
430
+ # Creates a digest for the current state of self.
444
431
  def __gibbler(digest_type=nil)
445
432
  klass = self.class
446
433
  d = self.keys.sort { |a,b| a.inspect <=> b.inspect }
447
- d.collect! do |name|
434
+ d.collect! do |name|
448
435
  value = self[name]
449
436
  unless value.respond_to? :__gibbler
450
437
  gibbler_debug klass, :skipping, name
451
438
  next
452
439
  end
453
440
  '%s:%s:%s' % [value.class, name, value.__gibbler(digest_type)]
454
- end
441
+ end
455
442
  d = d.join(Gibbler.delimiter).__gibbler(digest_type)
456
443
  a = Gibbler.digest '%s:%s:%s' % [klass, d.size, d], digest_type
457
444
  gibbler_debug klass, a, [klass, d.size, d]
458
- a
445
+ a
459
446
  end
460
447
  end
461
-
448
+
462
449
  # Creates a digest based on:
463
- # * parse each element into an Array of digests like: <tt>CLASS:INDEX:VALUE.__gibbler</tt>
464
- # * The gibbler method is called on each element so if it is a Hash or Array etc it
465
- # will be parsed recursively according to the gibbler method for that class type.
466
- # * Digest the Array of digests
467
- # * Return the digest for <tt>class:length:value</tt> where:
450
+ # * parse each element into an Array of digests like: `CLASS:INDEX:VALUE.__gibbler`
451
+ # * The gibbler method is called on each element so if it is a Hash or Array etc it
452
+ # will be parsed recursively according to the gibbler method for that class type.
453
+ # * Digest the Array of digests
454
+ # * Return the digest for `class:length:value` where:
468
455
  # * "class" is equal to the current object class (e.g. Array).
469
456
  # * "length" is the size of the Array of digests (which should equal
470
457
  # the number of elements in the original Array object).
471
458
  # * "value" is the Array of digests joined with a colon (":").
472
459
  #
473
- # This method can be used by any class with an <tt>each</tt> method.
460
+ # This method can be used by any class with an `each` method.
474
461
  #
475
- # class MyNamedArray
462
+ # class MyNamedArray
476
463
  # include Gibbler::Array
477
464
  # end
478
465
  #
479
466
  module Array
480
467
  include Gibbler::Object
481
-
468
+
482
469
  def self.included(obj)
483
470
  obj.extend Attic
484
471
  obj.attic :gibbler_cache
485
472
  end
486
-
487
- # Creates a digest for the current state of self.
473
+
474
+ # Creates a digest for the current state of self.
488
475
  def __gibbler(digest_type=nil)
489
476
  klass = self.class
490
477
  d, index = [], 0
491
- self.each_with_index do |value,idx|
478
+ self.each_with_index do |value,idx|
492
479
  unless value.respond_to? :__gibbler
493
480
  gibbler_debug klass, :skipping, idx
494
481
  next
@@ -502,29 +489,29 @@ class Gibbler < String
502
489
  a
503
490
  end
504
491
  end
505
-
506
- # Creates a digest based on: <tt>CLASS:LENGTH:TIME</tt>.
507
- # Times are calculated based on the equivalent time in UTC.
492
+
493
+ # Creates a digest based on: `CLASS:LENGTH:TIME`.
494
+ # Times are calculated based on the equivalent time in UTC.
508
495
  # e.g.
509
- #
496
+ #
510
497
  # Time.parse('2009-08-25 16:43:53 UTC') => 73b4635f
511
498
  # Time.parse('2009-08-25 12:43:53 -04:00') => 73b4635f
512
499
  #
513
500
  # To use use method in other classes simply:
514
501
  #
515
- # class ClassLikeTime
502
+ # class ClassLikeTime
516
503
  # include Gibbler::Time
517
504
  # end
518
505
  #
519
506
  module Time
520
507
  include Gibbler::Object
521
-
508
+
522
509
  def self.included(obj)
523
510
  obj.extend Attic
524
511
  obj.attic :gibbler_cache
525
512
  end
526
-
527
- # Creates a digest for the current state of self.
513
+
514
+ # Creates a digest for the current state of self.
528
515
  def __gibbler(digest_type=nil)
529
516
  klass = self.class
530
517
  value = self.nil? ? "\0" : self.utc.strftime('%Y-%m-%d %H:%M:%S UTC')
@@ -533,29 +520,29 @@ class Gibbler < String
533
520
  a
534
521
  end
535
522
  end
536
-
537
- # Creates a digest based on: <tt>CLASS:LENGTH:DATETIME</tt>.
538
- # Dates are calculated based on the equivalent datetime in UTC.
523
+
524
+ # Creates a digest based on: `CLASS:LENGTH:DATETIME`.
525
+ # Dates are calculated based on the equivalent datetime in UTC.
539
526
  # e.g.
540
- #
527
+ #
541
528
  # DateTime.parse('2009-08-25T17:00:40+00:00') => ad64c769
542
529
  # DateTime.parse('2009-08-25T13:00:40-04:00') => ad64c769
543
530
  #
544
531
  # To use use method in other classes simply:
545
532
  #
546
- # class ClassLikeTime
533
+ # class ClassLikeTime
547
534
  # include Gibbler::Time
548
535
  # end
549
536
  #
550
537
  module DateTime
551
538
  include Gibbler::Object
552
-
539
+
553
540
  def self.included(obj)
554
541
  obj.extend Attic
555
542
  obj.attic :gibbler_cache
556
543
  end
557
-
558
- # Creates a digest for the current state of self.
544
+
545
+ # Creates a digest for the current state of self.
559
546
  def __gibbler(digest_type=nil)
560
547
  klass = self.class
561
548
  value = self.nil? ? "\0" : self.new_offset(0).to_s
@@ -563,36 +550,36 @@ class Gibbler < String
563
550
  gibbler_debug klass, a, [klass, value.size, value]
564
551
  a
565
552
  end
566
-
553
+
567
554
  end
568
-
569
- # Creates a digest based on: <tt>CLASS:EXCLUDE?:FIRST:LAST</tt>
555
+
556
+ # Creates a digest based on: `CLASS:EXCLUDE?:FIRST:LAST`
570
557
  # where EXCLUDE? is a boolean value whether the Range excludes
571
558
  # the last value (i.e. 1...100) and FIRST and LAST are the values
572
559
  # returned by Range#first and Range#last.
573
560
  # e.g.
574
- #
561
+ #
575
562
  # (1..100) => Range:false:1:100 => 54506352
576
563
  # (1...100) => Range:true:1:100 => f0cad8cc
577
564
  #
578
565
  # To use use method in other classes simply:
579
566
  #
580
- # class ClassLikeRange
567
+ # class ClassLikeRange
581
568
  # include Gibbler::Range
582
569
  # end
583
570
  #
584
571
  module Range
585
572
  include Gibbler::Object
586
-
573
+
587
574
  def self.included(obj)
588
575
  obj.extend Attic
589
576
  obj.attic :gibbler_cache
590
577
  end
591
-
592
- # Creates a digest for the current state of self.
578
+
579
+ # Creates a digest for the current state of self.
593
580
  def __gibbler(digest_type=nil)
594
581
  klass = self.class
595
- if self.nil?
582
+ if self.nil?
596
583
  first, last, exclude = "\0", "\0", "\0"
597
584
  else
598
585
  first, last, exclude = self.first, self.last, self.exclude_end?
@@ -601,10 +588,10 @@ class Gibbler < String
601
588
  gibbler_debug klass, a, [klass, exclude, first, last]
602
589
  a
603
590
  end
604
-
591
+
605
592
  end
606
-
607
- # Creates a digest based on: <tt>CLASS:\0</tt>
593
+
594
+ # Creates a digest based on: `CLASS:\0`
608
595
  #
609
596
  # e.g.
610
597
  #
@@ -618,7 +605,7 @@ class Gibbler < String
618
605
  obj.attic :gibbler_cache
619
606
  end
620
607
 
621
- # Creates a digest for the current state of self.
608
+ # Creates a digest for the current state of self.
622
609
  def __gibbler(digest_type=nil)
623
610
  klass = self.class
624
611
  a = Gibbler.digest "%s:%s" % [klass, "\0"], digest_type
@@ -626,34 +613,34 @@ class Gibbler < String
626
613
  a
627
614
  end
628
615
  end
629
-
630
- # Creates a digest based on: <tt>CLASS:PATHLENGTH:PATH</tt>
616
+
617
+ # Creates a digest based on: `CLASS:PATHLENGTH:PATH`
631
618
  # where PATHLENGTH is the length of the PATH string. PATH is
632
619
  # not modified in any way (it is not converted to an absolute
633
- # path).
634
- #
620
+ # path).
621
+ #
635
622
  # NOTE: You may expect this method to include other information
636
623
  # like the file contents and modified date (etc...). The reason
637
624
  # we do not is because Gibbler is concerned only about Ruby and
638
625
  # not the outside world. There are many complexities in parsing
639
626
  # file data and attributes which would make it difficult to run
640
- # across platforms and Ruby versions / engines. If you want to
627
+ # across platforms and Ruby versions / engines. If you want to
641
628
  #
642
629
  # e.g.
643
- #
630
+ #
644
631
  # File.new('.') # => c8bc8b3a
645
632
  # File.new('/tmp') # => 3af85a19
646
633
  # File.new('/tmp/') # => 92cbcb7d
647
- #
634
+ #
648
635
  module File
649
636
  include Gibbler::Object
650
-
637
+
651
638
  def self.included(obj)
652
639
  obj.extend Attic
653
640
  obj.attic :gibbler_cache
654
641
  end
655
-
656
- # Creates a digest for the current state of self.
642
+
643
+ # Creates a digest for the current state of self.
657
644
  def __gibbler(digest_type=nil)
658
645
  klass = self.class
659
646
  value = self.nil? ? "\0" : self.path
@@ -662,29 +649,7 @@ class Gibbler < String
662
649
  a
663
650
  end
664
651
  end
665
-
666
- ##--
667
- ## NOTE: this was used when Gibbler supported "include Gibbler". We
668
- ## now recommend the "include Gibbler::String" approach. This was an
669
- ## interesting approach so I'm keeping the code here for reference.
670
- ##def self.included(klass)
671
- ## # Find the appropriate Gibbler::* module for the inheriting class
672
- ## gibbler_module = Gibbler.const_get("#{klass}") rescue Gibbler::String
673
- ##
674
- ## # If a Gibbler module is not defined, const_get bubbles up
675
- ## # through the stack to find the constant. This will return
676
- ## # the global class (likely itself) so we enforce a default.
677
- ## gibbler_module = Gibbler::String if gibbler_module == klass
678
- ## gibbler_debug :constant, klass, gibbler_module
679
- ##
680
- ## klass.module_eval do
681
- ## include gibbler_module
682
- ## end
683
- ##
684
- ##end
685
- ##++
686
-
687
-
652
+
688
653
  end
689
654
 
690
655
  class String
@@ -694,8 +659,3 @@ class String
694
659
  end
695
660
  end
696
661
  end
697
-
698
-
699
-
700
-
701
-