The variable `records` is considered an "array of records", since to
Changed the code slightly, but forgot to change the reference made
here. This should refer to the variable `data`, not `records`.
## Records and Arrays (#170)
Neat idea. I was working with jQuery a lot last week and thinking along similar lines.
2. As an alternative to these two functions, create an adapter class
that can wrap around "array of records" data to provide a "record of
arrays" interface without actually moving data about.
I chose to run with this idea:
class MapToEnum
instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ }
def initialize(enum)
@enum = enum
end
def __enum__
@enum
end
def method_missing(meth, *args, &block)
@enum.map { |o| o.send(meth, *args, &block) }
end
end
def aor_to_roa(arr)
MapToEnum.new(arr)
end
def roa_to_aor(mte)
mte.__enum__
end
if __FILE__ == $PROGRAM_NAME
Person = Struct.new(:name, :age)
people = [ Person.new("James", 32),
Person.new("Dana", 33),
Person.new("Matthew", 36) ]
wrapped = aor_to_roa(people)
p wrapped.name
p wrapped.name[2]
p roa_to_aor(wrapped)
end
__END__
James Edward Gray II
···
On Jul 18, 2008, at 11:03 AM, Matthew Moss wrote:
Here's aor -> roa adapter that works with any class, it just sends the
methods to the base class as they come, so the behaviour for
exceptional conditions should be consistent with it, it also has a
persistent proxy, so the client can define extra functionality on it
if needed.
http://pastie.org/236858
This is an on the fly converter, it returns an cached array that gets
created the first time a "column" is accessed, this one verifies that
at least one record has the requested attribute.
http://pastie.org/236948
Then, a roa -> aor adapter, using the same principles as the first
case.
http://pastie.org/237062
And finally an "on the fly" converter, in this case I could't return a
proper record wothout knowing in advance the name of all the
attributes.
http://pastie.org/237081
Lucas.
···
On Jul 18, 1:03 pm, Matthew Moss <matthew.m...@gmail.com> wrote:
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
## Records and Arrays (#170)
I've gone for a fairly simple proxy based approach that doesn't do any real converting. When converting an array of records we return a wrapper object.
When you call (for example) name on that object you get back a proxy object that just stores that name.
When you then call [3] on that proxy object, the proxy retrieves the object at index 3 and calls the previously remembered method name on it.
The reverse conversion is similar. the conversion function just returns a wrapper object, and wrapper[2] is just a proxy that remembers that index. When you call a method on the proxy
it forwards it to the record of arrays to obtain the appropriate array and retrieves the index element. A limitation is that the wrapper object just understands the [] method. It doesn't for example know how many elements it contains.
Nothing particular about OpenStruct is relied upon (eg activerecord objects work just fine, or just any old objects for example eg, roa_to_aor(aor_to_roa(data)) works)
My wrappers also allow assigning (the assignment gets passed through to the original object)
usage example:
#setup some test data
require 'ostruct'
data = []
data << OpenStruct.new( :name => 'fred', :color => 'red', :age => 22)
data << OpenStruct.new( :name => "paul", :color => "blue", :age => 30)
data << OpenStruct.new( :name => 'henry', :color => 'pink', :age => 23)
data << OpenStruct.new( :name => 'claire', :color => 'orange', :age => 19)
rec = OpenStruct.new
rec.name = %w(fred paul henry)
rec.age = [10,20,30]
rec.food = %w(pizza cake burger)
#real stuff begins here
x = aor_to_roa data
x.name[2] #=> "henry"
x.name[2] = 'sarah'
data[2] #> => #<OpenStruct name="sarah", color="pink", age=23>
y = roa_to_aor rec
y[1].age #=> 20
y[2].food = 'ice-cream'
rec.food #=> ["pizza", "cake", "ice-cream"]
#Composing:
x = roa_to_aor(aor_to_roa(data))
x[1].name #=> "paul"
x[1].name = "charlie"
data[1].name => "charlie"
y= aor_to_roa(roa_to_aor(rec))
y.name[1] #=> "paul"
y.name[1] = "alice"
rec.name #=> ["fred", "alice", "henry"]
With aor_to_roa I succumbed to a desire for cuteness, so for example
x.name #=> ["fred", "paul", "henry", "claire"]
x.name.class #=> Array (Even though it isn't)
x.name.collect {|s| s.upcase} #=> ["FRED", "PAUL", "HENRY", "CLAIRE"]
ie it can really look like an array if you want it to (but this isn't very efficient as it's materializing the array over and over again. this could probably be improved on). I didn't do the same for roa_to_aor.
If one was feeling particularly enthusiastic, sticking some pluralization rules into method missing would allow one to do (given the above data) x.names[2] rather than x.name[2] which reads slightly nicer
Fred
CODE:
def roa_to_aor(rec)
RecordOfArraysWrapper.new(rec)
end
def aor_to_roa(arr)
ArrayOfRecordsWrapper.new(arr)
end
class ArrayOfRecordsWrapper
def initialize(array)
@array = array
end
def method_missing(name, *args)
FieldProxy.new(@array, name)
end
class FieldProxy
instance_methods.each { |m| undef_method m unless m =~ /(^__)/ }
def initialize array, name
@array, @name = array, name
end
def [](index)
@array[index].send @name
end
def []=(index,value)
@array[index].send(@name.to_s + '=', value)
end
def to_a
@field_array = @array.collect {|a| a.send @name}
end
def method_missing(*args, &block)
to_a.send *args, &block
end
end
end
class RecordOfArraysWrapper
def initialize(record)
@record = record
end
def [](index)
RecordProxy.new(@record, index)
end
class RecordProxy
def initialize(record, index)
@record, @index = record, index
end
def method_missing(name, *args)
if name.to_s =~ /(.*)=$/
@record.send($1)[@index]=args.first
else
@record.send(name)[@index]
end
end
end
end
Matthew Moss ha scritto:
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
The three rules of Ruby Quiz 2:
1. Please do not post any solutions or spoiler discussion for this
quiz until 48 hours have passed from the time on this message.2. Support Ruby Quiz 2 by submitting ideas as often as you can! (A
permanent, new website is in the works for Ruby Quiz 2. Until then,
please visit the temporary website at<http://splatbang.com/rubyquiz/>\.
3. Enjoy!
Suggestion: A [QUIZ] in the subject of emails about the problem
helps everyone on Ruby Talk follow the discussion. Please reply to
the original quiz message, if you can.-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
## Records and Arrays (#170)
In a typical application, you might use what is commonly referred to
as an "array of records." Essentially, this is a single array
containing multiple objects that represent the same kind of structured
data, either as defined class or OpenStruct instances. Take, for
example, this bit of code that reads in some data regarding people:
their names, ages and favorite colors.require 'ostruct'
data =
File.open("data.txt").each do |line|
name, age, color = line.chomp.split(/,/)
d = OpenStruct.new
d.name = name
d.age = age
d.color = color
data << d
endThe variable `records` is considered an "array of records", since to
get any particular piece of data, you must first access it as an array
(to get a particular record), then access it as a record (to get a
particular field).> p data[3].name
=> "Matthew"> p data[3].age
=> 36However, at times, it is more convenient to store data as a "record of
arrays". Instead of one array containing multiple records, you have
one object (i.e. record) containing multiple, parallel arrays. Access
to data then is done first as a record, then as an array.> p data.name[3]
=> "Matthew"> p data.age[3]
=> 36This sort of arrangement is useful when you want to access series of
data at a time. For example, if I have a graphing component that takes
two arrays -- one for the domain axis, and another for the range axis
-- a "record of arrays" will make accessing that data trivial.*Your task this week* is to define two functions that move data
between "array of records" storage and "record of arrays" storage.def aor_to_roa(arr)
# This method accepts an array of records, and
# should return a single record of arrays.
#
# This is your task!
enddef roa_to_aor(rec)
# This method accepts a record of arrays, and
# should return a single array of records.
#
# This is also your task!
endYou should make this work with [OpenStruct][1]; do not limit yourself
to the example records shown above.There are two, optional extra-credits for this week.
1. Extend these two functions to accept arbitrary classes.
2. As an alternative to these two functions, create an adapter class
that can wrap around "array of records" data to provide a "record of
arrays" interface without actually moving data about.[1]: http://www.ruby-doc.org/stdlib/libdoc/ostruct/rdoc/classes/OpenStruct.html
Hi all,
here's my solution:
require 'ostruct'
def aor_to_roa(arr)
hash = { }
arr.each do |record|
record.marshal_dump.each_key { |field| (hash[field] ||= ) << record.send(field) }
end
OpenStruct.new(hash)
end
def roa_to_aor(rec)
result =
rec.marshal_dump.each do |field, array|
array.each_with_index { |value, index| (result[index] ||= OpenStruct.new).send("#{field}=", value) }
end
result
end
my solution (including a simple test)
require 'ostruct'
require 'test/unit'
# solution by rolando abarca - funkaster@gmail.com
module Quiz170
def self.aor_to_roa(arr)
os = OpenStruct.new
arr.each do |o|
# another way to get the keys:
# keys = (o.methods - OpenStruct.new.methods).delete_if { |m| m.match(/=$/) }
o.instance_variable_get("@table").keys.each { |k|
(os.send(k).nil? ? os.send("#{k}=", []) : os.send(k)) << o.send(k)
}
end
os
end
def self.roa_to_aor(rec)
arr = []
table = rec.instance_variable_get("@table")
size = table[table.keys.first].size
0.upto(size-1) { |i|
obj = OpenStruct.new
table.keys.each { |k| obj.send("#{k}=", table[k][i]) }
arr << obj
}
arr
end
end
class TestQuiz170 < Test::Unit::TestCase
def setup
@data = []
1.upto(100) { |i|
_t = OpenStruct.new
_t.name = "t#{i}"
_t.data = (rand * 1000).round
@data << _t
}
@roa = Quiz170.aor_to_roa(@data)
end
def test_001
1.upto(100) {
idx = (rand * 100).to_i
assert_equal @data[idx].name, @roa.name[idx]
assert_equal @data[idx].data, @roa.data[idx]
}
end
def test002
assert_equal @data, Quiz170.roa_to_aor(@roa)
end
end
regards,
rolando./
Here's my solution - playing w/ anonymous classes for the adapter solutions, probably not ideal since it doesn't provide all the methods a proper Array or arbitrary record would provide, but was fun to try out 
require 'ostruct'
def extract_attributes(rec)
if rec.kind_of?(OpenStruct)
attributes = rec.marshal_dump.keys
else
attributes = rec.public_methods
attributes.delete_if do |a|
!(a =~ /^[a-z_]*$/i && attributes.include?("#{a}="))
end
end
attributes
end
def aor_to_roa(arr)
attributes = extract_attributes(arr.first)
roa = arr.first.class.new
attributes.each { |a| roa.send("#{a}=", []) }
arr.each do |rec|
attributes.each do |a|
roa.send(a).push(rec.send(a))
end
end
roa
end
def roa_to_aor(roa)
attributes = extract_attributes(roa)
arr = []
roa.send(attributes.first).size.times do |i|
arr[i] = roa.class.new
attributes.each do |a|
arr[i].send("#{a}=", roa.send(a)[i])
end
end
arr
end
class ROAAdapter
def initialize(arr)
@arr = arr
end
def method_missing(a)
arr = @arr
Class.new do
define_method(:[]) { |i| arr[i].send(a) }
end.new
end
end
class AORAdapter < Array
def initialize(roa)
@roa = roa
end
def [](i)
roa = @roa
Class.new do
define_method(:method_missing) { |a| roa.send(a)[i] }
end.new
end
end
-Dustin
cfp:~ > cat quiz-170.rb
···
On Jul 18, 2008, at 10:03 AM, Matthew Moss wrote:
## Records and Arrays (#170)
#
# quiz-170.rb
#
aor = [ Record[0,1,2], Record[3,4,5], Record[6,7,8] ]
y 'aor' => aor
y 'aor2roa(aor)' => aor2roa(aor)
y 'roa2aor(aor2roa(aor))' => roa2aor(aor2roa(aor))
BEGIN {
require 'yaml'
require 'rubygems'
require 'arrayfields'
class Record < Array.struct(%w( a b c ))
def to_yaml(*a, &b) to_hash.to_yaml(*a, &b) end
end
module Inline
def to_yaml_style() :inline end
end
Array.send :include, Inline
Record.send :include, Inline
def aor2roa aor
fields = aor.first.fields
rclass = aor.first.class
roa = rclass
aor.each do |record|
fields.each do |field|
(roa[field] ||= ) << record[field]
end
end
roa
end
def roa2aor roa
fields = roa.fields
rclass = roa.class
aor =
n = fields.map{|field| roa[field].size}.max
n.times do |i|
values = fields.map{|field| roa[field][i]}
aor << rclass[*values]
end
aor
end
}
cfp:~ > ruby quiz-170.rb
---
aor: [{a: 0, b: 1, c: 2}, {a: 3, b: 4, c: 5}, {a: 6, b: 7, c: 8}]
---
aor2roa(aor):
a: [0, 3, 6]
b: [1, 4, 7]
c: [2, 5, 8]
---
roa2aor(aor2roa(aor)): [{a: 0, b: 1, c: 2}, {a: 3, b: 4, c: 5}, {a: 6, b: 7, c: 8}]
a @ http://codeforpeople.com/
--
we can deny everything, except that we have the possibility of being better. simply reflect on that.
h.h. the 14th dalai lama
Here's my solution which works with OpenStruct only, I didn't do any
extra credit.
-Adam
require 'ostruct'
def aor_to_roa(arr)
# This method accepts an array of records, and
# returns a single record of arrays.
rec = OpenStruct.new
return rec if ! arr[0] #empty array => empty record
vars = (arr[0].methods - rec.methods)
setters = vars.select{|m|m[-1]==?=}.sort
getters = (vars-setters).sort!
vars = getters.zip setters
vars.each{|get,set| rec.send(set, Array.new)}
arr.each{|item|
vars.each{|get,set|
rec.send(get)<< item.send(get)
}
}
rec
end
def roa_to_aor(rec)
# This method accepts a record of arrays, and
# returns a single array of records.
arr=
vars = (rec.methods - OpenStruct.new.methods)
setters = vars.select{|m|m[-1]==?=}.sort
getters = (vars-setters).sort!
vars = getters.zip setters
vars.each {|get,set|
rec.send(get).each_with_index{|value,i|
arr[i]||=OpenStruct.new
arr[i].send(set,value)
}
}
arr
end
···
On 7/18/08, Matthew Moss <matthew.moss@gmail.com> wrote:
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
*Your task this week* is to define two functions that move data
between "array of records" storage and "record of arrays" storage.
You should make this work with [OpenStruct][1]; do not limit yourself
to the example records shown above.
at last, I get track of this quiz(#170)…(^_^;)
*Your task this week* is to define two functions that move data
between "array of records" storage and "record of arrays" storage.
wow, interesting(^_^)
it sounds like rewriting a C-code into BASIC-code (and back).
and You may be saying Ruby provides a way
like Worm-Hole-jump: very-short cut.
I don't think I could find a best answer,
but i'll try pushing data into RDB and
pull things out in transverse of Row&Column…
class AORAdapter < Array
oops, this should've just been:
class AORAdapter
complete (revised) source below:
require 'ostruct'
def extract_attributes(rec)
if rec.kind_of?(OpenStruct)
attributes = rec.marshal_dump.keys
else
attributes = rec.public_methods
attributes.delete_if do |a|
!(a =~ /^[a-z_]*$/i && attributes.include?("#{a}="))
end
end
attributes
end
def aor_to_roa(arr)
attributes = extract_attributes(arr.first)
roa = arr.first.class.new
attributes.each { |a| roa.send("#{a}=", ) }
arr.each do |rec|
attributes.each do |a|
roa.send(a).push(rec.send(a))
end
end
roa
end
def roa_to_aor(roa)
attributes = extract_attributes(roa)
arr =
roa.send(attributes.first).size.times do |i|
arr[i] = roa.class.new
attributes.each do |a|
arr[i].send("#{a}=", roa.send(a)[i])
end
end
arr
end
class ROAAdapter
def initialize(arr)
@arr = arr
end
def method_missing(a)
arr = @arr
Class.new do
define_method(:) { |i| arr[i].send(a) }
end.new
end
end
class AORAdapter
def initialize(roa)
@roa = roa
end
def (i)
roa = @roa
Class.new do
define_method(:method_missing) { |a| roa.send(a)[i] }
end.new
end
end
Mine:
require 'ostruct'
class AryOfRecs
def initialize
@ary = []
end
def <<(record)
@ary << record
keys = ( record.respond_to?("marshal_dump") ? record.marshal_dump.keys :
record.instance_variables)
keys.each { |key|
roa_way(key.to_s.sub("@","")) if
record.respond_to?(key.to_s.sub("@",""))
}
end
def [](index)
return @ary[index]
end
def to_a
@ary
end
private
def roa_way(attrib)
instance_eval(
%(def #{attrib}
@ary.map { |rec| rec.#{attrib} }
end))
end
end
I only made the wrapper for an array of records, I't can be filled as in the
example:
data = AryOfRecs.new
File.open("data.txt").each do |line|
name, age, color = line.chomp.split(/,/)
d = OpenStruct.new
d.name = name
d.age = age
d.color = color
data << d
end
puts data[2].name
puts data.name[2]
Or with a class:
class Person
attr_accessor :name, :age, :color
end
data = AryOfRecs.new
File.open("data.txt").each do |line|
name, age, color = line.chomp.split(/,/)
d = Person.new
d.name = name
d.age = age
d.color = color
data << d
end
puts data[2].name
puts data.name[1]
···
--
Ash Mac durbatulûk, ash Mac gimbatul, ash Mac thrakatulûk agh burzum-ishi
krimpatul.
Juanger. http://xocoruby.blogspot.com