Module: Dotum::RuleOptionsDSL

Included in:
AbstractRules::Base, StandardOptions::Destination
Defined in:
lib/dotum/rule_options_dsl.rb

Defined Under Namespace

Classes: OptionConfig

Instance Method Summary collapse

Instance Method Details

#eval_options_block(&block) ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/dotum/rule_options_dsl.rb', line 97

def eval_options_block(&block)
  options = Dotum::OptionsContext.new(option_configs)
  options.instance_eval(&block)

  options
end

#expand_shorthand(*args) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/dotum/rule_options_dsl.rb', line 79

def expand_shorthand(*args)
  result = {}
  shorthand_config.zip(args).each do |config, value|
    case config
    when Symbol then result[config] = value
    when Hash
      if value.is_a? Hash
        result[config.keys.first]   = value.keys.first
        result[config.values.first] = value.values.first
      else
        result[config.keys.first] = value
      end
    end
  end

  result
end

#option_configs ⇒ Object

Configuration Management



52
53
54
55
56
 
# File 'lib/dotum/rule_options_dsl.rb', line 52

def option_configs
  @memoized_option_configs ||= ancestors.reverse_each.reduce({}) { |result, ancestor|
    result.merge(ancestor.instance_variable_get(:@option_configs) || {})
  }
end

#option_defaults ⇒ Object 



58
59
60
61
62
63
64
 
# File 'lib/dotum/rule_options_dsl.rb', line 58

def option_defaults
  @memoized_option_defaults ||= {}.tap do |defaults|
    option_configs.each do |option, config|
      defaults[option] = config[:default] unless config[:default].nil?
    end
  end
end

#optional(option, default = nil, &block) ⇒ Object 



22
23
24
 
# File 'lib/dotum/rule_options_dsl.rb', line 22

def optional(option, default=nil, &block)
  (@option_configs ||= {})[option] = OptionConfig.new(block, nil, default)
end

#preprocessor_methods ⇒ Object 



66
67
68
69
70
 
# File 'lib/dotum/rule_options_dsl.rb', line 66

def preprocessor_methods
  @memoized_preprocessor_methods ||= ancestors.map { |ancestor|
    ancestor.instance_variable_get(:@preprocessors)
  }.compact.flatten
end

#register_preprocessor(sym) ⇒ Object 



43
44
45
46
 
# File 'lib/dotum/rule_options_dsl.rb', line 43

def register_preprocessor(sym)
  @preprocessors ||= []
  @preprocessors.push(sym)
end

#required(option, &block) ⇒ Object 



15
16
17
18
19
20
 
# File 'lib/dotum/rule_options_dsl.rb', line 15

def required(option, &block)
  (@option_configs ||= {})[option] = OptionConfig.new(
    block,
    proc { |v| "Option '#{option}' is required." if v.nil? }
  )
end

#shorthand(*args) ⇒ Object

DSL



11
12
13
 
# File 'lib/dotum/rule_options_dsl.rb', line 11

def shorthand(*args)
  @shorthand_config ||= args
end

#shorthand_config ⇒ Object 



72
73
74
75
76
77
 
# File 'lib/dotum/rule_options_dsl.rb', line 72

def shorthand_config
  return @shorthand_config if defined? @shorthand_config
  return superclass.shorthand_config if superclass.respond_to? :shorthand_config

  []
end

#standard(option) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/dotum/rule_options_dsl.rb', line 26

def standard(option)
  option_module_name = option.to_s.split("_").map(&:capitalize).join.to_sym

  begin
    option_module = Dotum::StandardOptions.const_get(option_module_name)
  rescue LoadError
    raise "Unknown standard option '#{option}'.  Tried to load Dotum::StandardOptions::#{option_module_name}: #{$!.message}"
  end

  module_configs = option_module.instance_variable_get(:@option_configs)
  unless module_configs && module_configs[option]
    raise "Dotum::StandardOptions::#{option_module_name} is misconfigured; expected it to define the option '#{option}'"
  end

  include option_module
end

#validate_options(options) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/dotum/rule_options_dsl.rb', line 104

def validate_options(options)
  errors = []
  option_configs.each do |option, config|
    next unless validator = config[:validator]
    next unless error = validator.call(options[option])

    errors.push(error)
  end

  errors.size > 0 ? errors : nil
end