module Forme

  1. lib/forme.rb
  2. lib/forme/bs3.rb
  3. lib/forme/erb.rb
  4. lib/forme/form.rb
  5. lib/forme/input.rb
  6. lib/forme/rails.rb
  7. lib/forme/raw.rb
  8. lib/forme/sinatra.rb
  9. lib/forme/tag.rb
  10. lib/forme/transformers/error_handler.rb
  11. lib/forme/transformers/formatter.rb
  12. lib/forme/transformers/helper.rb
  13. lib/forme/transformers/inputs_wrapper.rb
  14. lib/forme/transformers/labeler.rb
  15. lib/forme/transformers/serializer.rb
  16. lib/forme/transformers/wrapper.rb
  17. lib/forme/version.rb
  18. show all

Constants

CONFIGURATIONS = {:default=>{}}  

Hash storing all configurations. Configurations are groups of related transformers, so that you can specify a single :config option when creating a Form and have all of the transformers set from that.

SHARED_WRAPPERS = [:tr, :table, :ol, :fieldset_ol]  

Transformer symbols shared by wrapper and inputs_wrapper

TRANSFORMERS = {}  

Main hash storing the registered transformers. Maps transformer type symbols to subhashes containing the registered transformers for that type. Those subhashes should have symbol keys and values that are either classes or objects that respond to call.

TRANSFORMER_TYPES = [:formatter, :serializer, :wrapper, :error_handler, :helper, :labeler, :inputs_wrapper, :tag_wrapper, :set_wrapper]  

Array of all supported transformer types.

VERSION = '1.5.0'.freeze  

Version constant, use Forme.version instead.

Attributes

default_add_blank_prompt [RW]

The default prompt to use for the :add_blank option (default: nil).

default_config [RW]

Set the default configuration to use if none is explicitly specified (default: :default).

Public Class methods

attr_classes (attr, *classes)

Update the :class entry in the attr hash with the given classes.

[show source]
# File lib/forme.rb, line 73
def self.attr_classes(attr, *classes)
  attr[:class] = merge_classes(attr[:class], *classes)
end
form (*a, &block)

Call Forme::Form.form with the given arguments and block.

[show source]
# File lib/forme.rb, line 68
def self.form(*a, &block)
  Form.form(*a, &block)
end
merge_classes (*classes)

Return a string that includes all given class strings

[show source]
# File lib/forme.rb, line 78
def self.merge_classes(*classes)
  classes.compact.join(' ')
end
raw (s)

Create a RawString using the given string, which will disable automatic escaping for that string.

[show source]
# File lib/forme.rb, line 84
def self.raw(s)
  RawString.new(s)
end
register_config (type, hash)

Register a new configuration. Type is the configuration name symbol, and hash maps transformer type symbols to transformer name symbols.

[show source]
# File lib/forme.rb, line 61
def self.register_config(type, hash)
  CONFIGURATIONS[type] = CONFIGURATIONS[hash.fetch(:base, :default)].merge(hash)
end
register_transformer (type, sym, obj=nil, &block)

Register a new transformer with this library. Arguments:

type

Transformer type symbol

sym

Transformer name symbol

obj/block

Transformer to associate with this symbol. Should provide either obj or block, but not both. If obj is given, should be either a Class instance or it should respond to call. If a Class instance is given, instances of that class should respond to call, and a new instance of that class should be used for each transformation.

[show source]
# File lib/forme.rb, line 53
def self.register_transformer(type, sym, obj=nil, &block)
  raise Error, "Not a valid transformer type" unless TRANSFORMERS.has_key?(type)
  raise Error, "Must provide either block or obj, not both" if obj && block
  TRANSFORMERS[type][sym] = obj||block
end
transform (type, trans_name, default_opts, *args, &block)

If there is a related transformer, call it with the given args and block. Otherwise, attempt to return the initial input without modifying it.

[show source]
# File lib/forme.rb, line 90
def self.transform(type, trans_name, default_opts, *args, &block)
  if trans = transformer(type, trans_name, default_opts)
    trans.call(*args, &block)
  else
    case type
    when :inputs_wrapper
      yield
    when :labeler, :error_handler, :wrapper, :helper, :set_wrapper, :tag_wrapper
      args.first
    else
      raise Error, "No matching #{type}: #{trans_name.inspect}"
    end
  end
end
transformer (type, trans, default_opts=nil)

Get the related transformer for the given transformer type. Output depends on the type of trans:

Symbol

Assume a request for a registered transformer, so look it up in the TRANSFORRMERS hash.

Hash

If type is also a key in trans, return the related value from trans, unless the related value is nil, in which case, return nil. If type is not a key in trans, use the default transformer for the receiver.

nil

Assume the default transformer for this receiver.

otherwise

return trans directly if it responds to call, and raise an Error if not.

[show source]
# File lib/forme.rb, line 113
def self.transformer(type, trans, default_opts=nil)
  case trans
  when Symbol
    type = :wrapper if type == :set_wrapper || type == :tag_wrapper
    TRANSFORMERS[type][trans] || raise(Error, "invalid #{type}: #{trans.inspect} (valid #{type}s: #{TRANSFORMERS[type].keys.map(&:inspect).join(', ')})")
  when Hash
    if trans.has_key?(type)
      if v = trans[type]
        transformer(type, v, default_opts)
      end
    else
      transformer(type, nil, default_opts)
    end
  when nil
    transformer(type, default_opts[type]) if default_opts
  else
    if trans.respond_to?(:call)
      trans
    else
      raise Error, "#{type} #{trans.inspect} must respond to #call"
    end
  end
end
version ()

Returns the version as a frozen string (e.g. '0.1.0')

[show source]
# File lib/forme/version.rb, line 8
def self.version
  VERSION
end