Carolyn Grant wrote in post #1083906:
basic_config = MySettings.new # Picks up & processes basic_config.yml
adv_config = MySettings.new # Picks up & processes adv_config.yml
In general it doesn't make any sense for an object to know its "name",
because an object may have zero or many names at any time. You can
assign the object reference to local variables, to global variables, to
instance variables of other objects, to constants, as elements of an
Array or Hash, etc.
In the above code, the object created by MySettings.new has no name at
the time it is created. Only after the #new function has returned the
object reference, it is assigned to the local variable.
So for the code you are writing above, I would strongly advise passing
the filename (or filename stem) as an argument:
basic_config = MySettings.new("basic_config.yaml")
adv_config = MySettings.new("adv_config.yaml")
Of course, as with many things in Ruby, there is an exception. The
exception is to do with class objects; that is, objects of class Class.
Normally classes are held in constants, and the first time a class is
assigned to a constant, it learns its name, and the name becomes an
attribute of the class itself.
A class definition like "class Foo" both creates the class and assigns
it to a constant, but you can see the behaviour if you first create an
anonymous class, and then later assign it to a constant.
foo = Class.new
=> #<Class:0x106c91650>
my_instance = foo.new
=> #<#<Class:0x106c91650>:0x106c8e6f8>
Bar = foo
=> Bar
foo
=> Bar
my_instance
=> #<Bar:0x106c8e6f8>
Baz = foo
=> Bar
foo
=> Bar
my_instance
=> #<Bar:0x106c8e6f8>
I tried my_class.name; that returns a "Method not defined" error" (I'm
using 1.9.3p194)
You'll have to show the code. I use ruby 1.8, but it works fine for me.
Notice that "name" is a method of the class, not the instance, and is
only for Class objects because of the special-case behaviour described
above.
foo.name
=> "Bar"
my_instance.class.name
=> "Bar"
my_instance.name
NoMethodError: undefined method `name' for #<Bar:0x106c8e6f8>
from (irb):11
What I'd really like to avoid is:
basic_config = MySettings.new(basic_config).
Why? It seems you want to create "magic" which will be very difficult
for another programmer to follow. When you create an object, you should
pass all the data which will be used to create state in that object, and
you should allow the caller to decide what to do with the returned
object.
The closest I could recommend is if you have a single config object
which holds all the sub-configs e.g. a hash. Then a single method
argument can say which file to load *and* which hash member to put it
in. For example:
require 'yaml'
class Configs
def initialize
@configs = {}
end
def load(stem)
@configs[stem] = File.open("#{stem}.yaml") do |f|
YAML.load(f)
end
end
def (stem)
@configs[stem]
end
end
config = Configs.new
config.load "basic_config"
config.load "adv_config"
puts config["basic_config"].inspect
Of course, if you want the config to be globally accessible throughout
your application, then you can assign it to a constant instead of a
local variable.
Config = Configs.new
Config.load "basic_config"
Config.load "adv_config"
puts Config["basic_config"].inspect
Or you could use a global variable, but a constant is generally
preferred. Constants can be put into namespaces, e.g. MyApp::Config, to
avoid clashes with other uses of Config.
···
--
Posted via http://www.ruby-forum.com/\.
