Module: Packable::Extensions::IO

Defined in:
lib/packable/extensions/io.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object

:nodoc:



7
8
9
10
11
 
# File 'lib/packable/extensions/io.rb', line 7

def self.included(base) #:nodoc:
  base.alias_method_chain :read, :packing
  base.alias_method_chain :write, :packing
  base.alias_method_chain :each, :packing
end

Instance Method Details

#>>(options) ⇒ Object

Usage:

io >> Class
io >> [Class, options]
io >> :shortcut



25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/packable/extensions/io.rb', line 25

def >> (options)
  r = []
  class << r
    attr_accessor :stream
    def >> (options)
      self << stream.read(options)
    end
  end
  r.stream = self
  r >> options
end

#each_with_packing(*options, &block) ⇒ Object 



55
56
57
58
59
 
# File 'lib/packable/extensions/io.rb', line 55

def each_with_packing(*options, &block)
  return each_without_packing(*options, &block) if (Integer === options.first) || (String === options.first)
  return Enumerator.new(self, :each_with_packing, *options) unless block_given?
  yield read(*options) until eof?
end

#pack_and_write(*arg) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/packable/extensions/io.rb', line 85

def pack_and_write(*arg)
  original_pos = pos
  Packable::Packers.to_object_option_list(*arg).each do |obj, options|
    if options[:write_packed]
      options[:write_packed].bind(obj).call(self)
    else
      obj.write_packed(self, options)
    end
  end
  pos - original_pos
end

#packed ⇒ Object

Returns (or yields) a modified IO object that will always pack/unpack when writing/reading.



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/packable/extensions/io.rb', line 38

def packed
  packedio = clone
  packedio.set_encoding("ascii-8bit") if packedio.respond_to? :set_encoding 
  class << packedio
    def << (arg)
      arg = [arg, :default] unless arg.instance_of?(::Array)
      pack_and_write(*arg)
      self
    end
    def packed
      block_given? ? yield(self) : self
    end
    alias_method :write, :pack_and_write #bypass test for argument length
  end
  block_given? ? yield(packedio) : packedio
end

#pos_change(&block) ⇒ Object

Returns the change in io.pos caused by the block. Has nothing to do with packing, but quite helpful and so simple…



15
16
17
18
19
 
# File 'lib/packable/extensions/io.rb', line 15

def pos_change(&block)
  delta =- pos
  yield
  delta += pos
end

#read_exactly(n) ⇒ Object

returns a string of exactly n bytes, or else raises an EOFError

Raises:

  • (EOFError) 


78
79
80
81
82
83
 
# File 'lib/packable/extensions/io.rb', line 78

def read_exactly(n)
  return "" if n.zero?
  s = read_without_packing(n)
  raise EOFError if s.nil? || s.length < n
  s
end

#read_with_packing(*arg) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/packable/extensions/io.rb', line 65

def read_with_packing(*arg)
  return read_without_packing(*arg) if arg.length == 0 || arg.first.nil? || arg.first.is_a?(Numeric)
  values = Packable::Packers.to_class_option_list(*arg).map do |klass, options, original|
    if options[:read_packed]
      options[:read_packed].call(self)
    else
      klass.read_packed(self, options)
    end
  end
  return values.size > 1 ? values : values.first
end

#write_with_packing(*arg) ⇒ Object 



61
62
63
 
# File 'lib/packable/extensions/io.rb', line 61

def write_with_packing(*arg)
  (arg.length == 1) ? write_without_packing(*arg) : pack_and_write(*arg)
end