Class: Sunrise::Utils::Settingslogic

Inherits:
Hash
  • Object
show all
Defined in:
lib/sunrise/utils/settingslogic.rb

Overview

A simple settings solution using a YAML file. See README for more information.

Direct Known Subclasses

SystemSettings

Defined Under Namespace

Classes: MissingSetting

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(hash_or_file = self.class.source, section = nil) ⇒ Settingslogic

Initializes a new settings object. You can initialize an object in any of the following ways:

Settings.new(:application) # will look for config/application.yml
Settings.new("application.yaml") # will look for application.yaml
Settings.new("/var/configs/application.yml") # will look for /var/configs/application.yml
Settings.new(:config1 => 1, :config2 => 2)

Basically if you pass a symbol it will look for that file in the configs directory of your rails app, if you are using this in rails. If you pass a string it should be an absolute path to your settings file. Then you can pass a hash, and it just allows you to access the hash via methods.



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/sunrise/utils/settingslogic.rb', line 100

def initialize(hash_or_file = self.class.source, section = nil)
  #puts "new! #{hash_or_file}"
  case hash_or_file
  when nil
    raise Errno::ENOENT, "No file specified as Settingslogic source"
  when Hash
    self.replace hash_or_file
  else
    hash = YAML.load(ERB.new(File.read(hash_or_file)).result).to_hash
    hash = hash[self.class.namespace] if self.class.namespace
    self.replace hash
  end
  @section = section || self.class.source  # so end of error says "in application.yml"
  create_accessors!
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object

Called for dynamically-defined keys, and also the first key deferenced at the top-level, if load! is not used. Otherwise, create_accessors! (called by new) will have created actual methods for each key.

Raises:



118
119
120
121
122
123
124
 
# File 'lib/sunrise/utils/settingslogic.rb', line 118

def method_missing(name, *args, &block)
  key = name.to_s
  raise MissingSetting, "Missing setting '#{key}' in #{@section}" unless has_key? key
  value = fetch(key)
  create_accessor_for(key)
  value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
end

Class Method Details

.[](key) ⇒ Object 



42
43
44
 
# File 'lib/sunrise/utils/settingslogic.rb', line 42

def [](key)
  instance.fetch(key.to_s, nil)
end

.[]=(key, val) ⇒ Object 



46
47
48
49
50
51
 
# File 'lib/sunrise/utils/settingslogic.rb', line 46

def []=(key, val)
  # Setting[:key][:key2] = 'value' for dynamic settings
  val = new(val, source) if val.is_a? Hash
  instance.store(key.to_s, val)
  instance.create_accessor_for(key, val)
end

.get(key) ⇒ Object

Enables Settings.get(‘nested.key.name’) for dynamic access



17
18
19
20
21
22
23
24
 
# File 'lib/sunrise/utils/settingslogic.rb', line 17

def get(key)
  parts = key.split('.')
  curs = self
  while p = parts.shift
    curs = curs.send(p)
  end
  curs
end

.load! ⇒ Object 



53
54
55
56
 
# File 'lib/sunrise/utils/settingslogic.rb', line 53

def load!
  instance
  true
end

.name ⇒ Object

:nodoc:



12
13
14
 
# File 'lib/sunrise/utils/settingslogic.rb', line 12

def name # :nodoc:
  instance.key?("name") ? instance.name : super
end

.namespace(value = nil) ⇒ Object 



34
35
36
37
38
39
40
 
# File 'lib/sunrise/utils/settingslogic.rb', line 34

def namespace(value = nil)
  if value.nil?
    @namespace
  else
    @namespace = value
  end
end

.reload! ⇒ Object 



58
59
60
61
 
# File 'lib/sunrise/utils/settingslogic.rb', line 58

def reload!
  @instance = nil
  load!
end

.source(value = nil) ⇒ Object 



26
27
28
29
30
31
32
 
# File 'lib/sunrise/utils/settingslogic.rb', line 26

def source(value = nil)
  if value.nil?
    @source
  else
    @source = value
  end
end

Instance Method Details

#[](key) ⇒ Object 



126
127
128
 
# File 'lib/sunrise/utils/settingslogic.rb', line 126

def [](key)
  fetch(key.to_s, nil)
end

#[]=(key, val) ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/sunrise/utils/settingslogic.rb', line 130

def []=(key,val)
  # Setting[:key][:key2] = 'value' for dynamic settings
  val = self.class.new(val, @section) if val.is_a? Hash
  store(key.to_s, val)
  create_accessor_for(key, val)
end

#create_accessor_for(key, val = nil) ⇒ Object

Use instance_eval/class_eval because they’re actually more efficient than define_method{} stackoverflow.com/questions/185947/ruby-definemethod-vs-def bmorearty.wordpress.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/



150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/sunrise/utils/settingslogic.rb', line 150

def create_accessor_for(key, val=nil)
  return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
  instance_variable_set("@#{key}", val) if val
  self.class.class_eval <<-EndEval
    def #{key}
      return @#{key} if @#{key}
      raise MissingSetting, "Missing setting '#{key}' in #{@section}" unless has_key? '#{key}'
      value = fetch('#{key}')
      @#{key} = value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
    end
  EndEval
end

#create_accessors! ⇒ Object

This handles naming collisions with Sinatra/Vlad/Capistrano. Since these use a set() helper that defines methods in Object, ANY method_missing ANYWHERE picks up the Vlad/Sinatra settings! So settings.deploy_to title actually calls Object.deploy_to (from set :deploy_to, “host”), rather than the app_yml hash. Jeezus.



141
142
143
144
145
 
# File 'lib/sunrise/utils/settingslogic.rb', line 141

def create_accessors!
  self.each do |key,val|
    create_accessor_for(key)
  end
end