Module: ModelFormatter

Defined in:
lib/model_formatter.rb

Overview

:nodoc:

Defined Under Namespace

Modules: ClassMethods

Constant Summary collapse

DEFAULT_FORMAT_PREFIX = 
'formatted_'

Class Method Summary collapse

Class Method Details

.append_features(base) ⇒ Object

:nodoc:



20
21
22
23
 
# File 'lib/model_formatter.rb', line 20

def self.append_features(base) # :nodoc:
  super
  base.extend(ClassMethods)
end

.define_formatter(attr, &formatter) ⇒ Object

Define a formatter like the actual physical classes this could easily be done with text and an eval… but this should be faster



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/model_formatter.rb', line 53

def self.define_formatter(attr, &formatter) # :nodoc:
  # The convention is to name these custom formatters
  # differently than the other formatting classes
  class_name = "CustomFormat#{attr.to_s.camelize}"

  # Create a class in the same module as the others
  clazz = Class.new(Formatters::Format)
  silence_warnings do
    Formatters.const_set class_name, clazz
  end

  # Define the class body
  clazz.class_eval &formatter
  return clazz.new
end

.formatter_for(type_name, options = {}) ⇒ Object

Return the formatter for a class, formatter object, symbol, or string defining the name of a formatter class. If it’s a symbol, check the Formatters module for the class that matches the camelized name of the symbol with ‘Format’ prepended. Options hash is passed to the instantiation of the formatter object.

Raises:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/model_formatter.rb', line 74

def self.formatter_for(type_name, options = {}) # :nodoc:
  # If the type_name is an instance of a formatter, just return with it
  return type_name if type_name.is_a? Formatters::Format

  # If the type_name is a class just assign it to the formatter_class for instantiation later
  formatter_class = type_name if type_name.is_a? Class

  # Format a symbol or string into a formatter_class
  if type_name.is_a? Symbol or type_name.is_a? String
    type_name = type_name.to_s.camelize

    # Construct the class name from the type_name
    formatter_name = "Format#{type_name}"
    formatter_class = nil
    begin
      formatter_class = Formatters.const_get(formatter_name)
    rescue NameError => ne
      # Ignore this, caught below
    end
  end

  # Make sure the name of this is found in the Formatters module and that
  # it's the correct superclass
  return formatter_class.new(options) unless formatter_class.nil? or
                                              formatter_class.superclass != Formatters::Format

  raise Formatters::FormatNotFoundException.new("Cannot find formatter 'Formatters::#{formatter_name}'")
end

.init_options(defaults, model, attr) ⇒ Object

:nodoc:



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/model_formatter.rb', line 25

def self.init_options(defaults, model, attr) # :nodoc:
  options = defaults.dup
  options[:attr] = attr
  options[:prefix] ||= DEFAULT_FORMAT_PREFIX
  options[:formatted_attr] ||= "#{options[:prefix]}#{attr}"

  # If :as is set, then it must be either a formatter Class, formatter Object, Symbol, or String
  options[:formatter] = formatter_for(options[:as], options[:options]) unless options[:as].nil?

  # Define the formatter from a :block if :block is defined
  options[:formatter] = define_formatter(attr, &options[:block]) unless options[:block].nil?

  # Define :formatter from a block based on :from and :to if they're both set
  if !options[:from].nil? and !options[:to].nil?
    options[:formatter] = Module.new
    options[:formatter].class.send :define_method, :from, options[:from]
    options[:formatter].class.send :define_method, :to, options[:to]
  end

  # If :as is still not defined raise an error
  raise 'No formatting options have been defined.' if options[:formatter].nil?

  options
end