Struct equivalent with rails-y keyword args hash?

ruby-talk
1

I have some code which uses Structs. I'd rather use keyword args. I'm
generating data objects to store MIDI note data, and it's kind of
hideously unreadable:

Note.new(2, 43, 0.25, 127, now += interval)

This would be much nicer:

Note.new(:channel => 2,
         :note => 43,
         :duration => 0.25,
         :velocity => 127,
         :time => now += interval)

(God I wish I could configure bloody Gmail to use monospaced fonts.)

Anyway, is there an easy equivalent to Struct which, instead of taking
stuff in sequence, takes a Hash of options, in a Rails-y style? Like a
HashStruct? Does Facets have such a thing, maybe haps? If not, is the
basic code for Struct in Ruby, and/or is a class like Struct but with
Hashes easy to build?

···

--
Giles Bowkett

Podcast: http://hollywoodgrit.blogspot.com
Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org
Tumblelog: http://giles.tumblr.com

2

i use this alot in rails projects:

require 'attributes'

class OpenObject
   alias_method "__inspect__", "inspect"
   alias_method "__to_s__", "to_s"
   alias_method "__instance_eval__", "instance_eval"

     instance_methods.each{|m| undef_method m unless m[%r/__/]}

   alias_method "instance_eval", "__instance_eval__"
   alias_method "inspect", "__inspect__"
   alias_method "to_s", "__to_s__"

   def method_missing m, *a, &b
     super if(a.empty? and b.nil?)
     m = m.to_s
     setter = m.delete!('=') || a.first || b
     if setter
       if a.empty?
         __attribute__ m, &b
       else
         __attribute__ m => a.shift
       end
     else
       nil
     end
   end

   def configure kvs = {}, &b
     kvs.each{|k,v| __attribute__ k => v}
     __instance_eval__ &b if b
   end
   alias_method "initialize", "configure"
   alias_method "eval", "configure"

   def __singleton_class__ &b
     sc =
       class << self
         self
       end
     b ? sc.module_eval(&b) : sc
   end

   def extend *a, &b
     if b
       __singleton_class__ &b
       self
     else
       super
     end
   end
   alias_method "extending", "extend"

   def attributes *a, &b
     __attributes__ *a, &b
   end

   def to_hash
     __attributes__.inject(Hash.new){|h,a| h.update a => __send__(a)}
   end

   def as_query
     require 'cgi'
     e = lambda{|x| CGI.escape x.to_s}
     to_hash.map{|k,v| "#{ e[k] }=#{ e[v] }"}.join("&")
   end

   def respond_to? *a, &b
     true
   end
end
def openobject(*a, &b) OpenObject.new(*a, &b) end

class Object
   def Open *a, &b
     OpenObject.new(*a, &b)
   end
end

it's all that and so much more.

a @ http://codeforpeople.com/

···

On Jan 8, 2008, at 10:02 PM, Giles Bowkett wrote:

Anyway, is there an easy equivalent to Struct which, instead of taking
stuff in sequence, takes a Hash of options, in a Rails-y style? Like a
HashStruct? Does Facets have such a thing, maybe haps? If not, is the
basic code for Struct in Ruby, and/or is a class like Struct but with
Hashes easy to build?

--
share your knowledge. it's a way to achieve immortality.
h.h. the 14th dalai lama

3

One possibility, method for Note only:

manveru@pi ~ % irb
class Note < Struct.new(:channel, :note, :duration, :velocity, :time)
  def self.create(hash)
    new(*hash.values_at(*members.map{|m| m.to_sym}))
  end
end
# nil
Note.create(:channel => 1, :note => 2, :duration => 3, :velocity => 3,
:time => Time.now)
# #<struct Note channel=1, note=2, duration=3, velocity=3, time=Wed
Jan 09 14:36:21 +0900 2008>

Second one, method for all Structs:

manveru@pi ~ % irb
class Struct
  def self.create(hash)
    new(*hash.values_at(*members.map{|m| m.to_sym}))
  end
end
# nil
Note = Struct.new(:channel, :note, :duration, :velocity, :time)
# Note
Note.create(:channel => 1, :note => 2, :duration => 3, :velocity => 3,
:time => Time.now)
# #<struct Note channel=1, note=2, duration=3, velocity=3, time=Wed
Jan 09 14:37:20 +0900 2008>

···

On Jan 9, 2008 2:02 PM, Giles Bowkett <gilesb@gmail.com> wrote:

I have some code which uses Structs. I'd rather use keyword args. I'm
generating data objects to store MIDI note data, and it's kind of
hideously unreadable:

Note.new(2, 43, 0.25, 127, now += interval)

This would be much nicer:

Note.new(:channel => 2,
         :note => 43,
         :duration => 0.25,
         :velocity => 127,
         :time => now += interval)

(God I wish I could configure bloody Gmail to use monospaced fonts.)

Anyway, is there an easy equivalent to Struct which, instead of taking
stuff in sequence, takes a Hash of options, in a Rails-y style? Like a
HashStruct? Does Facets have such a thing, maybe haps? If not, is the
basic code for Struct in Ruby, and/or is a class like Struct but with
Hashes easy to build?

4

Then just use that form.

Kind regards

robert

···

2008/1/9, Giles Bowkett <gilesb@gmail.com>:

I have some code which uses Structs. I'd rather use keyword args. I'm
generating data objects to store MIDI note data, and it's kind of
hideously unreadable:

Note.new(2, 43, 0.25, 127, now += interval)

This would be much nicer:

Note.new(:channel => 2,
         :note => 43,
         :duration => 0.25,
         :velocity => 127,
         :time => now += interval)

--
use.inject do |as, often| as.you_can - without end

5

One way is:

require "ostruct"

now = Time.now
interval = 5
note = OpenStruct.new( :channel => 2,
                            :note => 43,
                            :duration => 0.25,
                            :velocity => 127,
                            :time => now + interval )
note.channel # => 2
note.velocity # => 127

__END__

James Edward Gray II

···

On Jan 8, 2008, at 11:02 PM, Giles Bowkett wrote:

I have some code which uses Structs. I'd rather use keyword args. I'm
generating data objects to store MIDI note data, and it's kind of
hideously unreadable:

Note.new(2, 43, 0.25, 127, now += interval)

This would be much nicer:

Note.new(:channel => 2,
        :note => 43,
        :duration => 0.25,
        :velocity => 127,
        :time => now += interval)

6

This thread has been idle for a while, but in case anybody's still
watching...

I've long wanted the same thing as was originally requested, and I too
couldn't find a gem anywhere that has it. So I wrote one. See

      http://rubygems.org/gems/key_struct

Hope it's useful to others. Hope if I've re-invented the wheel somebody
will point me to an existing gem.

···

--
Posted via http://www.ruby-forum.com/.

7

several good suggestions but I think this is the one I'll run with:

Second one, method for all Structs:

manveru@pi ~ % irb
class Struct
  def self.create(hash)
    new(*hash.values_at(*members.map{|m| m.to_sym}))
  end
end
# nil
Note = Struct.new(:channel, :note, :duration, :velocity, :time)
# Note
Note.create(:channel => 1, :note => 2, :duration => 3, :velocity => 3,
:time => Time.now)
# #<struct Note channel=1, note=2, duration=3, velocity=3, time=Wed
Jan 09 14:37:20 +0900 2008>

Ara's seems the most robust, but with so much going on and no specs it
makes me antsy; the OpenStruct looks good too but I want classes as
well as instances.

···

--
Giles Bowkett

Podcast: http://hollywoodgrit.blogspot.com
Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org
Tumblelog: http://giles.tumblr.com

8

Folks, why do you run around implementing something? The desired behavior *is already present* with Struct.

Cheers

  robert

···

On 09.01.2008 19:13, Giles Bowkett wrote:

several good suggestions but I think this is the one I'll run with:

Second one, method for all Structs:

manveru@pi ~ % irb
class Struct
  def self.create(hash)
    new(*hash.values_at(*members.map{|m| m.to_sym}))
  end
end
# nil
Note = Struct.new(:channel, :note, :duration, :velocity, :time)
# Note
Note.create(:channel => 1, :note => 2, :duration => 3, :velocity => 3,
:time => Time.now)
# #<struct Note channel=1, note=2, duration=3, velocity=3, time=Wed
Jan 09 14:37:20 +0900 2008>

Ara's seems the most robust, but with so much going on and no specs it
makes me antsy; the OpenStruct looks good too but I want classes as
well as instances.

9

Folks, why do you run around implementing something? The desired
behavior *is already present* with Struct.

I tried your code example, and it didn't work.

class Note < Struct.new(:channel) ; end

Note.new(:channel => 2)
Note.channel # => "{:channel => 2}"

It just stores the hash.

···

--
Giles Bowkett

Podcast: http://hollywoodgrit.blogspot.com
Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org
Tumblelog: http://giles.tumblr.com

10

Argh!! You are right, I am wrong. I'm sorry, should have payed attention more closely to the output of #inspect. I think I'll better shut up now.

Cheers

  robert

···

On 09.01.2008 19:37, Giles Bowkett wrote:

Folks, why do you run around implementing something? The desired
behavior *is already present* with Struct.

I tried your code example, and it didn't work.

class Note < Struct.new(:channel) ; end

Note.new(:channel => 2)
Note.channel # => "{:channel => 2}"

It just stores the hash.

11

Hm, could not resist... Here is another variant:

Note = Struct.new(:channel, :note, :duration, :velocity, :time) do
  def self.create(hash)
    new(*members.map {|me| hash[me.to_sym]})
  end
end

irb(main):016:0* now = interval = 1
=> 1
irb(main):017:0> n = Note.new(:channel => 2,
irb(main):018:1* :note => 43,
irb(main):019:1* :duration => 0.25,
irb(main):020:1* :velocity => 127,
irb(main):021:1* :time => now += interval)
=> #<struct Note channel={:channel=>2, :note=>43, :duration=>0.25,
:velocity=>127, :time=>2}, note=nil, duration=nil, ve
locity=nil, time=nil>
irb(main):022:0>

:slight_smile:

robert

···

2008/1/10, Robert Klemme <shortcutter@googlemail.com>:

On 09.01.2008 19:37, Giles Bowkett wrote:
>> Folks, why do you run around implementing something? The desired
>> behavior *is already present* with Struct.
>
> I tried your code example, and it didn't work.
>
> class Note < Struct.new(:channel) ; end
>
> Note.new(:channel => 2)
> Note.channel # => "{:channel => 2}"
>
> It just stores the hash.

Argh!! You are right, I am wrong. I'm sorry, should have payed
attention more closely to the output of #inspect. I think I'll better
shut up now.

--
use.inject do |as, often| as.you_can - without end