1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
module DBF
# An instance of DBF::Record represents a row in the DBF file
class Record
# Initialize a new DBF::Record
#
# @param data [String, StringIO] data
# @param columns [Column]
# @param version [String]
# @param memo [DBF::Memo]
def initialize(data, columns, version, memo)
@data = StringIO.new(data)
@columns = columns
@version = version
@memo = memo
end
# Equality
#
# @param [DBF::Record] other
# @return [Boolean]
def ==(other)
other.respond_to?(:attributes) && other.attributes == attributes
end
# Reads attributes by column name
#
# @param name [String, Symbol] key
def [](name)
key = name.to_s
if attributes.key?(key)
attributes[key]
elsif (index = underscored_column_names.index(key))
attributes[@columns[index].name]
end
end
# Record attributes
#
# @return [Hash]
def attributes
@attributes ||= Hash[column_names.zip(to_a)]
end
# Do all search parameters match?
#
# @param [Hash] options
# @return [Boolean]
def match?(options)
options.all? { |key, value| self[key] == value }
end
# Maps a row to an array of values
#
# @return [Array]
def to_a
@to_a ||= @columns.map { |column| init_attribute(column) }
end
private
def column_names # :nodoc:
@column_names ||= @columns.map(&:name)
end
def get_data(column) # :nodoc:
@data.read(column.length)
end
def get_memo(column) # :nodoc:
if @memo
@memo.get(memo_start_block(column))
else
# the memo file is missing, so read ahead to next record and return nil
@data.read(column.length)
nil
end
end
def init_attribute(column) # :nodoc:
value = column.memo? ? get_memo(column) : get_data(column)
column.type_cast(value)
end
def memo_start_block(column) # :nodoc:
data = get_data(column)
data = data.unpack1('V') if %w[30 31].include?(@version)
data.to_i
end
def method_missing(method, *args) # :nodoc:
if (index = underscored_column_names.index(method.to_s))
attributes[@columns[index].name]
else
super
end
end
def respond_to_missing?(method, *) # :nodoc:
underscored_column_names.include?(method.to_s) || super
end
def underscored_column_names # :nodoc:
@underscored_column_names ||= @columns.map(&:underscored_name)
end
end
end
|
