In a class:
app/models/years.rb
class Years
def self.get_years
Rails.cache.fetch(‘years’) {(1920..Time.now.strftime(’%Y’).to_i).entries}
end

def self.update_years
if self.get_years.max < Time.now.strftime(’%Y’).to_i
Rails.cache.delete(‘years’)
self.get_years
end
end
end

use Years.get_years to return a cached version of the years.
use Years.update_years to update the cache with the current year dataset…might want to schedule updates for every night at 12:00AM.
Note that if you are running mongrel each cache is seen as a separate store unless you go with memcached…
You can get crazy with caching using memcached if you have a data set that you really want to have highly available/distributed.

The key is striking the balance, and you’ll know for sure if you’ve done this if it’s maintainable.

nice solution, any improvements since ?

My form field entry is now:

My application wide helper is :

def channel_select(f)
f.collection_select(:source, CHANNEL_SELECT_COLLECTION, :label, :value, {:prompt => ‘Select Channel Source’})
end

And my code in environment.rb is

LabelValue = Struct.new(:label, :value)
CHANNEL_SOURCES_ARRAY = ['abc', 'def', 'ghi']
CHANNEL_SELECT_COLLECTION = CHANNEL_SOURCES_ARRAY.collect { |chan| LabelValue.new(chan,chan) }

I am cautiosly wary about editing such code into environment.rb, might move the array content out specific env files, or just put something into /lib

any thoughts ?

You are the man. Here is my the pertinent code in my “environment.rb” file. I just deleted the LabelValue class entirely. It very much reminds me of the bean declarations in the Application Context, no?

# ——- Structs
LabelValue = Struct.new(:label,:value)

# ——- Constant Values

# Year array
YEARS_ARRAY = (1920..2008).entries

# Year collection
YEARS_SELECT_COLLECTION = YEARS_ARRAY.collect {|yr| LabelValue.new(yr,yr)}

….

From there, I just use the method in the helper file to populate the values — it’s all “static” so you get the single instance. Much, much cleaner.

Thanks

Just wondering if it would make more sense to auto-increment the max year so you don’t have to fix it with a New Years hangover once a year?

YEARS_ARRAY = (1920..Time.new.strftime(‘%Y’).to_i).entries

Cheers
Ben

# ——- Structs
LabelValue = Struct.new(:label,:value)

# ——- Constant Values

# Year array
YEARS_ARRAY = (1920..2008).entries

# Year collection
YEARS_SELECT_COLLECTION = YEARS_ARRAY.collect {|yr| LabelValue.new(yr,yr)}

….

From there, I just use the method in the helper file to populate the values — it’s all “static” so you get the single instance. Much, much cleaner.

Thanks.

I looked hard at using the “Struct” instead of the accessors, and still might do this. I had a worry that I might want to do “more” with the class at a later point, but the nice thing about Ruby is that your classes can be quite mutable without affecting their future functionality.

As far as putting the collection into a constant, you’re absolutely right. I just missed that and it would definitely be an enhancement!

Always so much to learn. Nice comment!

LabelValue = Struct.new(:label, :value)

This will create a new class called LabelValue with accessors for label and value. Plus, it creates a constructor, so you can create instances like this:

obj = LabelValue.new(‘mylabel’, ‘myvalue’)

Also, you may wish to look at Ruby ranges to do the year array. Your constant could also be created like this:

YEARS_ARRAY = (1920..2008).entries

By the way, your year_lookup re-builds the select collection array every time it is called. You might want to put it in a constant (or class variable). Here is how I would do it:

YEARS_SELECT_COLLECTION = YEARS_ARRAY.collect {|yr| LabelValue.new(yr,yr)}

Happy New Year.
-Tc