Module: Kramdown::Options

Defined in:
lib/kramdown/options.rb

Overview

This module defines all options that are used by parsers and/or converters as well as providing methods to deal with the options.

Defined Under Namespace

Classes: Boolean, Definition

Constant Summary collapse

ALLOWED_TYPES =

Allowed option types.

[String, Integer, Float, Symbol, Boolean, Object]

Class Method Summary collapse

Class Method Details

.defaults ⇒ Object

Return a Hash with the default values for all options.



80
81
82
83
84
 
# File 'lib/kramdown/options.rb', line 80

def self.defaults
  temp = {}
  @options.each {|n, o| temp[o.name] = o.default}
  temp
end

.define(name, type, default, desc, &block) ⇒ Object

Define a new option called name (a Symbol) with the given type (String, Integer, Float, Symbol, Boolean, Object), default value default and the description desc. If a block is specified, it should validate the value and either raise an error or return a valid value.

The type ‘Object’ should only be used for complex types for which none of the other types suffices. A block needs to be specified when using type ‘Object’ and it has to cope with a value given as string and as the opaque type.

Raises:

  • (ArgumentError) 


61
62
63
64
65
66
67
 
# File 'lib/kramdown/options.rb', line 61

def self.define(name, type, default, desc, &block)
  raise ArgumentError, "Option name #{name} is already used" if @options.has_key?(name)
  raise ArgumentError, "Invalid option type #{type} specified" if !ALLOWED_TYPES.include?(type)
  raise ArgumentError, "Invalid type for default value" if !(type === default) && !default.nil?
  raise ArgumentError, "Missing validator block" if type == Object && block.nil?
  @options[name] = Definition.new(name, type, default, desc, block)
end

.defined?(name) ⇒ Boolean

Return true if an option called name is defined.

Returns:



75
76
77
 
# File 'lib/kramdown/options.rb', line 75

def self.defined?(name)
  @options.has_key?(name)
end

.definitions ⇒ Object

Return all option definitions.



70
71
72
 
# File 'lib/kramdown/options.rb', line 70

def self.definitions
  @options
end

.merge(hash) ⇒ Object

Merge the #defaults Hash with the parsed options from the given Hash, i.e. only valid option names are considered and their value is run through the #parse method.



88
89
90
91
92
93
94
95
 
# File 'lib/kramdown/options.rb', line 88

def self.merge(hash)
  temp = defaults
  hash.each do |k,v|
    next unless @options.has_key?(k)
    temp[k] = parse(k, v)
  end
  temp
end

.parse(name, data) ⇒ Object

Parse the given value data as if it was a value for the option name and return the parsed value with the correct type.

If data already has the correct type, it is just returned. Otherwise it is converted to a String and then to the correct type.

Raises:

  • (ArgumentError) 


102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/kramdown/options.rb', line 102

def self.parse(name, data)
  raise ArgumentError, "No option named #{name} defined" if !@options.has_key?(name)
  if !(@options[name].type === data)
    data = data.to_s
    data = if @options[name].type == String
             data
           elsif @options[name].type == Integer
             Integer(data) rescue raise Kramdown::Error, "Invalid integer value for option '#{name}': '#{data}'"
           elsif @options[name].type == Float
             Float(data) rescue raise Kramdown::Error, "Invalid float value for option '#{name}': '#{data}'"
           elsif @options[name].type == Symbol
             (data.strip.empty? ? nil : data.to_sym)
           elsif @options[name].type == Boolean
             data.downcase.strip != 'false' && !data.empty?
           end
  end
  data = @options[name].validator[data] if @options[name].validator
  data
end

.simple_array_validator(val, name, size) ⇒ Object

Ensures that the option value val for the option called name is a valid array. The parameter val can be

  • a comma separated string which is split into an array of values

  • or an array.

Additionally, the array is checked for the correct size.



135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/kramdown/options.rb', line 135

def self.simple_array_validator(val, name, size)
  if String === val
    val = val.split(/,/)
  elsif !(Array === val)
    raise Kramdown::Error, "Invalid type #{val.class} for option #{name}"
  end
  if val.size != size
    raise Kramdown::Error, "Option #{name} needs exactly #{size} values"
  end
  val
end