ActiveProperty
I'm a Ruby on Rails developer and I was missing some functionalities in the area of property and configuration of applications. In my previous job as a Java developer, I used property files to define environment specific values. When moving from development to test or production changing the property files would configure file paths and so on.
RoR has a very powerfull testframework with fixtures so most of the property functionalities are not necessary anymore, because you can use the fixtures to do that. One area I couldn't get configured without the use of some kind of properties, paths for file modifications.
RoR has several environment.rb files to set some of the differences between production, test and development, but that is not very intuitive to me. That's why I wanted to use an
ActiveRecord to read and store my properties.
The ActiveProperty was born..
The main reason why I wanted something like an ActiveProperty is because:
- I wanted a clear distinction between production properties and test properties.
- By storing these properties as ActiveRecord, we can use fixtures to make sure we can test everything without have to write testspecific stuff like "path = '/../mocks/test/' if RAILS_ENV == 'test' " in controllers and models.
- Using the a scaffold controller on the ActiveProperty gives you an easy interface to maintain the properties.
For test purposes these properties can be simply overridden by the active_properties.yml fixture
This is especially handy when working with files. Production paths can be loaded with migrations and functional tests use values from the fixture.
By superclassing ActiveProperty, you can create multiple scopes for your properties.
Usage:
Superclass this class and set your scope fe ApplicationProperty
- ApplicationProperty.spoon -> "no key found"
- ApplicationProperty.spoon = "There is no spoon" -> "There is no spoon"
- ApplicationProperty.spoon -> "There is no spoon"
Author: Jeroen Knoops
Company: ViCi BV - Eindhoven
ActiveProperty application:
ActiveProperty.zipactive_property.rb:
# ActiveProperty.
#
# This class can be used to store properties. The main reason why I made this is because
# I wanted a clear distinction between production properties and test properties.
# By storing these properties as ActiveRecord, we can use fixtures.
#
# For test purposes these properties can be simply overridden by the active_properties.yml fixture
# This is especially handy when working with files. Production paths can be loaded with migrations and functional tests use values from the fixture.
#
# By superclassing ActiveProperty, you can create multiple scopes for your properties.
# Usage:
# Superclass this class and set your scope fe ApplicationProperty
# * ApplicationProperty.spoon -> "no key found"
# * ApplicationProperty.spoon = "There is no spoon" -> "There is no spoon"
# * ApplicationProperty.spoon -> "There is no spoon"
#
# Maintaining the properties can be done by scaffolding the ActiveProperty model.
#
# Author: Jeroen Knoops jeroen@vici-nl.com
# Company: ViCi BV - Eindhoven
class ActiveProperty < ActiveRecord::Base
@scope = self.name
class << self
def method_missing(method_id, *args)
begin
super(method_id, args)
rescue
method_id_string = method_id.id2name
if method_id_string[method_id_string.length - 1] == 61
result = set_value(@scope, method_id_string[0...-1], args[0])
else
result = get_value(@scope, method_id.id2name)
end
result || "No active property found in scope #{@scope} for: #{method_id}"
end
end
private
def get_value(scope, key)
ap = find(:first, :conditions => ["`key` = ? and `scope` = ?", key, scope])
if ap
return ap.value
end
return nil
end
def set_value(scope, key, value)
ap = find(:first, :conditions => ["`key` = ? and `scope` = ?", key, scope])
if ap
ap.value = value
ap.save!
else
self.create!(:scope => scope,
:key => key,
:value => value)
end
end
end
end
